tirtc-devtools-cli 0.0.1

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HostState = void 0;
+class HostState {
+    service = { state: 'stopped' };
+    connection = { state: 'idle' };
+    streams = new Map();
+    subscriptions = new Set();
+    internalConnections = new Set();
+    streamRequestPolicy = { mode: 'manual' };
+    streamSourceBindings = new Map();
+    protocolVersion = '1.0.0';
+    serverVersion = '1.0.0';
+    runtimeTarget = 'runtime-backed/unknown';
+    hostEndpoint = 'stdio://runtime-backed';
+    startedAt = new Date().toISOString();
+    lastError;
+}
+exports.HostState = HostState;

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

@@ -0,0 +1,81 @@
+import { PreviewRegistration } from './WebPreviewGateway';
+import { StreamSource } from './HostState';
+export type RuntimeEventPayload = Record<string, unknown>;
+export interface RuntimeCommandResponse {
+    sequenceNumber: number;
+    payloadEncoding: string;
+    payload: string;
+}
+export interface RuntimeSendStartResult {
+    autoStarted: boolean;
+    workerPid?: number;
+}
+export type OutputAttachResult = {
+    outputId: string;
+    targetPath: string;
+    attachedAt: string;
+    preview?: PreviewRegistration;
+};
+export interface RuntimeAdapter {
+    readonly runtimeTarget: string;
+    readonly hostEndpoint: string;
+    readonly runtimeBundleRoot: string;
+    readonly repoRoot: string;
+    readonly platform: string;
+    setEventHandler(handler: (family: string, kind: string, payload: RuntimeEventPayload) => void): void;
+    startService(serviceEntry: string | undefined, license: string, timeoutMs: number): Promise<string>;
+    stopService(): Promise<void>;
+    connect(serviceEntry: string | undefined, peerId: string, token: string, timeoutMs: number): Promise<string>;
+    disconnect(): Promise<void>;
+    startSendStream(streamId: number, media: string, source: StreamSource): Promise<RuntimeSendStartResult>;
+    stopSendStream(streamId: number): 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>;
+    detachOutput(outputId: string): Promise<void>;
+    sendCommand(commandId: number, kind: string, payloadEncoding: string, payload: string, replyToSequenceNumber?: number, awaitResponse?: boolean, timeoutMs?: number): Promise<RuntimeCommandResponse | undefined>;
+}
+type RuntimeBackedAdapterOptions = {
+    runtimeBundleRoot: string;
+    platform: string;
+};
+export declare class RuntimeBackedAdapter implements RuntimeAdapter {
+    readonly runtimeTarget: string;
+    readonly hostEndpoint = "stdio://runtime-backed";
+    readonly runtimeBundleRoot: string;
+    readonly repoRoot: string;
+    readonly platform: string;
+    private readonly sendWorker;
+    private readonly receiveWorker;
+    private eventHandler?;
+    private outputCounter;
+    private commandSequence;
+    private connected;
+    private defaultServiceEntry?;
+    private activeService?;
+    private connectionContext?;
+    private readonly outputs;
+    private readonly receiveStreams;
+    private readonly previewGateway;
+    private receiveRefreshTimer?;
+    constructor(options: RuntimeBackedAdapterOptions);
+    setEventHandler(handler: (family: string, kind: string, payload: RuntimeEventPayload) => void): void;
+    private emit;
+    private recordOutputEvent;
+    private assertRuntimeBundleReady;
+    private resolveServiceEntry;
+    private scheduleReceiveRefresh;
+    private refreshReceiveWorker;
+    startService(serviceEntry: string | undefined, license: string, timeoutMs: number): Promise<string>;
+    stopService(): Promise<void>;
+    connect(serviceEntry: string | undefined, peerId: string, token: string, timeoutMs: number): Promise<string>;
+    disconnect(): Promise<void>;
+    startSendStream(streamId: number, media: string, source: StreamSource): Promise<RuntimeSendStartResult>;
+    stopSendStream(streamId: number): 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>;
+    detachOutput(outputId: string): Promise<void>;
+    sendCommand(commandId: number, kind: string, payloadEncoding: string, payload: string, replyToSequenceNumber?: number, awaitResponse?: boolean, timeoutMs?: number): Promise<RuntimeCommandResponse | undefined>;
+}
+export {};

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

@@ -0,0 +1,559 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeBackedAdapter = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const RuntimeSendWorker_1 = require("./RuntimeSendWorker");
+const RuntimeReceiveWorker_1 = require("./RuntimeReceiveWorker");
+const WebPreviewGateway_1 = require("./WebPreviewGateway");
+function nowIsoString() {
+    return new Date().toISOString();
+}
+function pathExists(p) {
+    return fs.existsSync(p);
+}
+function ensureDir(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+}
+function tryGetNumber(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === 'string' && value.trim().length > 0) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return undefined;
+}
+function resolveRepoRoot() {
+    const explicit = process.env.TIRTC_REPO_ROOT;
+    const appServerRoot = process.env.TIRTC_APP_SERVER_ROOT;
+    const candidates = [
+        appServerRoot,
+        explicit,
+        process.cwd(),
+        path.resolve(process.cwd(), '..'),
+        path.resolve(__dirname, '../..'),
+        path.resolve(__dirname, '../../..'),
+        path.resolve(__dirname, '../../../..'),
+    ].filter((v) => typeof v === 'string' && v.trim().length > 0);
+    for (const candidate of candidates) {
+        const normalized = path.resolve(candidate);
+        if (pathExists(path.join(normalized, 'bin/runtime')) ||
+            pathExists(path.join(normalized, 'bin/native')) ||
+            pathExists(path.join(normalized, 'app-server/bin/runtime')) ||
+            pathExists(path.join(normalized, 'app-server'))) {
+            return normalized;
+        }
+    }
+    return appServerRoot && appServerRoot.trim().length > 0 ? path.resolve(appServerRoot) : path.resolve(process.cwd());
+}
+function resolveDefaultServiceEntry() {
+    const explicit = process.env.TIRTC_RUNTIME_SERVICE_ENTRY;
+    if (explicit && explicit.trim().length > 0) {
+        return explicit.trim();
+    }
+    return undefined;
+}
+function resolveOutputRoot() {
+    const explicitArtifactRoot = process.env.TIRTC_HOST_ARTIFACT_DIR;
+    if (explicitArtifactRoot && explicitArtifactRoot.trim().length > 0) {
+        return path.join(path.resolve(explicitArtifactRoot.trim()), 'received-media');
+    }
+    const explicit = process.env.TIRTC_HOST_OUTPUT_DIR;
+    if (explicit && explicit.trim().length > 0) {
+        return path.resolve(explicit.trim());
+    }
+    return path.join(path.resolve(process.cwd()), '.tmp', 'tirtc-devtool', 'output');
+}
+function normalizeMedia(media) {
+    if (media === 'audio') {
+        return 'audio';
+    }
+    if (media === 'video') {
+        return 'video';
+    }
+    return undefined;
+}
+function resolveStreamAssetsDir(source) {
+    if (source.mode !== 'local_assets') {
+        throw new Error('unsupported stream source mode: ' + String(source.mode ?? '<unknown>'));
+    }
+    const assetsDir = path.resolve(source.local_assets.assets_dir);
+    let stats;
+    try {
+        stats = fs.statSync(assetsDir);
+    }
+    catch {
+        throw new Error('stream local assets directory does not exist: ' + assetsDir);
+    }
+    if (!stats.isDirectory()) {
+        throw new Error('stream local assets path is not a directory: ' + assetsDir);
+    }
+    const manifestPath = path.join(assetsDir, 'manifest.json');
+    if (!pathExists(manifestPath)) {
+        throw new Error('stream local assets manifest not found: ' + manifestPath);
+    }
+    return assetsDir;
+}
+class RuntimeBackedAdapter {
+    runtimeTarget;
+    hostEndpoint = 'stdio://runtime-backed';
+    runtimeBundleRoot;
+    repoRoot;
+    platform;
+    sendWorker;
+    receiveWorker;
+    eventHandler;
+    outputCounter = 1;
+    commandSequence = 1;
+    connected = false;
+    defaultServiceEntry;
+    activeService;
+    connectionContext;
+    outputs = new Map();
+    receiveStreams = new Map();
+    previewGateway = new WebPreviewGateway_1.WebPreviewGateway();
+    receiveRefreshTimer;
+    constructor(options) {
+        this.runtimeBundleRoot = options.runtimeBundleRoot;
+        this.platform = options.platform;
+        this.runtimeTarget = 'runtime-backed/' + options.platform;
+        this.repoRoot = resolveRepoRoot();
+        this.sendWorker = new RuntimeSendWorker_1.RuntimeSendWorkerManager({
+            repoRoot: this.repoRoot,
+            platform: this.platform,
+            onLogLine: (payload) => {
+                this.emit('logs', 'runtime.line', payload);
+            },
+        });
+        this.receiveWorker = new RuntimeReceiveWorker_1.RuntimeReceiveWorkerManager({
+            repoRoot: this.repoRoot,
+            platform: this.platform,
+            onLogLine: (payload) => {
+                this.emit('logs', 'runtime.line', payload);
+            },
+        });
+    }
+    setEventHandler(handler) {
+        this.eventHandler = handler;
+    }
+    emit(family, kind, payload) {
+        this.recordOutputEvent(family, kind, payload);
+        if (!this.eventHandler) {
+            return;
+        }
+        this.eventHandler(family, kind, payload);
+    }
+    recordOutputEvent(family, kind, payload) {
+        if (this.outputs.size === 0) {
+            return;
+        }
+        const payloadStreamId = tryGetNumber(payload.streamId);
+        const timestamp = nowIsoString();
+        for (const output of this.outputs.values()) {
+            if (output.receiveBoundEver) {
+                continue;
+            }
+            if (payloadStreamId !== undefined && payloadStreamId !== output.streamId) {
+                continue;
+            }
+            const line = JSON.stringify({
+                at: timestamp,
+                family,
+                kind,
+                streamId: output.streamId,
+                payload,
+            }) + '\n';
+            try {
+                fs.appendFileSync(output.targetPath, line, 'utf8');
+            }
+            catch {
+                // no-op
+            }
+        }
+    }
+    assertRuntimeBundleReady() {
+        const includePath = path.join(this.runtimeBundleRoot, 'include');
+        const libPath = path.join(this.runtimeBundleRoot, 'lib');
+        const manifestPath = path.join(this.runtimeBundleRoot, 'manifest.txt');
+        if (!pathExists(includePath) || !pathExists(libPath) || !pathExists(manifestPath)) {
+            throw new Error('runtime bundle is not ready at ' + this.runtimeBundleRoot);
+        }
+    }
+    resolveServiceEntry(serviceEntry) {
+        if (serviceEntry && serviceEntry.trim().length > 0) {
+            return serviceEntry;
+        }
+        if (!this.defaultServiceEntry) {
+            this.defaultServiceEntry = resolveDefaultServiceEntry();
+        }
+        return this.defaultServiceEntry ?? '';
+    }
+    scheduleReceiveRefresh() {
+        if (this.receiveRefreshTimer) {
+            clearTimeout(this.receiveRefreshTimer);
+        }
+        this.receiveRefreshTimer = setTimeout(() => {
+            this.receiveRefreshTimer = undefined;
+            void this.refreshReceiveWorker();
+        }, 80);
+    }
+    async refreshReceiveWorker() {
+        if (!this.connected || !this.connectionContext) {
+            await this.receiveWorker.stopAll();
+            return;
+        }
+        const bindings = [];
+        for (const attachment of this.outputs.values()) {
+            if (!attachment.media) {
+                continue;
+            }
+            bindings.push({
+                key: attachment.outputId + "/" + String(attachment.streamId) + "/" + attachment.media,
+                serviceEntry: this.connectionContext.serviceEntry,
+                peerId: this.connectionContext.peerId,
+                token: this.connectionContext.token,
+                streamId: attachment.streamId,
+                media: attachment.media,
+                targetPath: attachment.targetPath,
+                framed: attachment.consumer === 'web_preview',
+            });
+        }
+        await this.receiveWorker.syncBindings(bindings);
+    }
+    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,
+            startedAt: nowIsoString(),
+        };
+        this.emit('service', 'start.requested', {
+            serviceEntry: resolvedServiceEntry,
+            licensePresent: license.length > 0,
+            timeoutMs,
+            senderBootstrapStarted: senderBootstrap.started,
+            senderWorkerPid: senderBootstrap.pid,
+            at: nowIsoString(),
+        });
+        return resolvedServiceEntry;
+    }
+    async stopService() {
+        this.activeService = undefined;
+        await this.sendWorker.stopAll();
+        await this.receiveWorker.stopAll();
+        if (this.receiveRefreshTimer) {
+            clearTimeout(this.receiveRefreshTimer);
+            this.receiveRefreshTimer = undefined;
+        }
+        this.previewGateway.dispose();
+        this.emit('service', 'stop.requested', { at: nowIsoString() });
+    }
+    async connect(serviceEntry, peerId, token, timeoutMs) {
+        this.assertRuntimeBundleReady();
+        const resolvedServiceEntry = this.resolveServiceEntry(serviceEntry);
+        this.emit('connection', 'connect.requested', {
+            serviceEntry: resolvedServiceEntry,
+            peerId,
+            tokenPresent: token.length > 0,
+            timeoutMs,
+            at: nowIsoString(),
+        });
+        this.connected = true;
+        this.connectionContext = {
+            serviceEntry: resolvedServiceEntry,
+            peerId,
+            token,
+        };
+        this.emit('connection', 'connect.validated', {
+            serviceEntry: resolvedServiceEntry,
+            peerId,
+            at: nowIsoString(),
+        });
+        const activeService = this.activeService;
+        if (activeService) {
+            this.emit('stream', 'send.auto.resume.requested', {
+                serviceEntry: activeService.serviceEntry,
+                startedAt: activeService.startedAt,
+                at: nowIsoString(),
+            });
+        }
+        await this.refreshReceiveWorker();
+        return resolvedServiceEntry;
+    }
+    async disconnect() {
+        this.connected = false;
+        this.connectionContext = undefined;
+        this.receiveStreams.clear();
+        await this.sendWorker.stopAll();
+        await this.receiveWorker.stopAll();
+        if (this.receiveRefreshTimer) {
+            clearTimeout(this.receiveRefreshTimer);
+            this.receiveRefreshTimer = undefined;
+        }
+        this.previewGateway.dispose();
+        this.emit('connection', 'disconnect.requested', { at: nowIsoString() });
+    }
+    async startSendStream(streamId, media, source) {
+        const assetsDir = resolveStreamAssetsDir(source);
+        const activeService = this.activeService;
+        let autoStarted = false;
+        let workerPid;
+        if (activeService) {
+            const key = String(streamId) + '/' + media;
+            const startResult = await this.sendWorker.startDeviceStream({
+                key,
+                serviceEntry: activeService.serviceEntry,
+                license: activeService.license,
+                assetsDir,
+                streamId,
+                media: media === 'audio' ? 'audio' : 'video',
+            });
+            autoStarted = startResult.started;
+            workerPid = startResult.pid;
+        }
+        this.emit('stream', 'send.start.requested', {
+            streamId,
+            media,
+            sourceMode: source.mode,
+            assetsDir,
+            connected: this.connected,
+            workerPid,
+            autoStarted,
+            deferred: !activeService,
+            at: nowIsoString(),
+        });
+        return { autoStarted, workerPid };
+    }
+    async stopSendStream(streamId) {
+        const keys = [String(streamId) + '/audio', String(streamId) + '/video'];
+        for (const key of keys) {
+            await this.sendWorker.stopStream(key);
+        }
+        this.emit('stream', 'send.stop.requested', { streamId, at: nowIsoString() });
+    }
+    async startReceiveStream(streamId, media) {
+        if (!this.connected) {
+            throw new Error('connection is not established');
+        }
+        const normalized = normalizeMedia(media);
+        if (!normalized) {
+            throw new Error('unsupported receive media: ' + media);
+        }
+        this.receiveStreams.set(streamId, normalized);
+        this.emit('stream', 'receive.start.requested', { streamId, media, at: nowIsoString() });
+        await this.refreshReceiveWorker();
+    }
+    async stopReceiveStream(streamId) {
+        this.receiveStreams.delete(streamId);
+        this.emit('stream', 'receive.stop.requested', { streamId, at: nowIsoString() });
+        await this.refreshReceiveWorker();
+    }
+    async attachOutput(streamId, consumer, mediaView, format, delivery, targetPath, maxFiles) {
+        if (!this.connected) {
+            throw new Error('connection is not established');
+        }
+        const outputId = 'rt-out-' + streamId + '-' + this.outputCounter;
+        this.outputCounter += 1;
+        const safeFormat = (format || 'bin').replace(/[^a-zA-Z0-9]/g, '').toLowerCase() || 'bin';
+        const resolvedTargetPath = targetPath && targetPath.trim().length > 0
+            ? path.resolve(targetPath)
+            : path.join(resolveOutputRoot(), `${outputId}.${safeFormat}`);
+        ensureDir(path.dirname(resolvedTargetPath));
+        let receiveMedia = this.receiveStreams.get(streamId);
+        if (!receiveMedia && consumer === 'web_preview') {
+            if (format.toLowerCase() === 'g711a' || format.toLowerCase() === 'alaw' || format.toLowerCase() === 'pcm') {
+                receiveMedia = 'audio';
+            }
+            else if (format.toLowerCase() === 'h264' || format.toLowerCase() === 'jpeg' || format.toLowerCase() === 'mjpeg') {
+                receiveMedia = 'video';
+            }
+            if (receiveMedia) {
+                this.receiveStreams.set(streamId, receiveMedia);
+            }
+        }
+        if (receiveMedia) {
+            for (const existing of this.outputs.values()) {
+                if (existing.streamId === streamId && existing.media === receiveMedia) {
+                    throw new Error(`output already attached for stream=${streamId} media=${receiveMedia}; detach existing output first`);
+                }
+            }
+        }
+        fs.writeFileSync(resolvedTargetPath, Buffer.alloc(0));
+        const attachedAt = nowIsoString();
+        let preview;
+        if (consumer === 'web_preview') {
+            if (!receiveMedia) {
+                throw new Error(`web_preview requires active receive stream binding for stream=${streamId}`);
+            }
+            preview = await this.previewGateway.registerSource(outputId, receiveMedia, streamId, resolvedTargetPath, async () => {
+                if (!this.connected) {
+                    throw new Error('connection is not established');
+                }
+                this.scheduleReceiveRefresh();
+                this.emit('stream', 'preview.start.requested', {
+                    streamId,
+                    media: receiveMedia,
+                    outputId,
+                    at: nowIsoString(),
+                });
+            }, async () => {
+                if (!this.connected) {
+                    return;
+                }
+                this.scheduleReceiveRefresh();
+                this.emit('stream', 'preview.stop.requested', {
+                    streamId,
+                    media: receiveMedia,
+                    outputId,
+                    at: nowIsoString(),
+                });
+            });
+        }
+        const attachment = {
+            outputId,
+            streamId,
+            media: receiveMedia,
+            consumer,
+            mediaView,
+            format,
+            delivery,
+            targetPath: resolvedTargetPath,
+            attachedAt,
+            receiveBoundEver: Boolean(receiveMedia),
+            preview,
+        };
+        this.outputs.set(outputId, attachment);
+        if (!receiveMedia) {
+            const bootstrapLine = JSON.stringify({
+                at: attachedAt,
+                family: 'stream',
+                kind: 'output.attach',
+                streamId,
+                outputId,
+                consumer,
+                mediaView,
+                format,
+                delivery,
+                maxFiles,
+            }) + '\n';
+            fs.appendFileSync(resolvedTargetPath, bootstrapLine, 'utf8');
+        }
+        if (receiveMedia && consumer !== 'web_preview') {
+            this.scheduleReceiveRefresh();
+        }
+        this.emit('stream', 'output.attach.requested', {
+            outputId,
+            streamId,
+            consumer,
+            mediaView,
+            format,
+            delivery,
+            targetPath: resolvedTargetPath,
+            maxFiles,
+            at: attachedAt,
+            runtimeDownlink: Boolean(receiveMedia),
+            preview,
+        });
+        return {
+            outputId,
+            targetPath: resolvedTargetPath,
+            attachedAt,
+            preview,
+        };
+    }
+    async detachOutput(outputId) {
+        const attachment = this.outputs.get(outputId);
+        if (attachment) {
+            if (attachment.consumer === 'web_preview') {
+                this.previewGateway.unregisterSource(outputId);
+            }
+            if (!attachment.receiveBoundEver) {
+                const line = JSON.stringify({
+                    at: nowIsoString(),
+                    family: 'stream',
+                    kind: 'output.detach',
+                    streamId: attachment.streamId,
+                    outputId,
+                }) + '\n';
+                try {
+                    fs.appendFileSync(attachment.targetPath, line, 'utf8');
+                }
+                catch {
+                    // no-op
+                }
+            }
+            this.outputs.delete(outputId);
+        }
+        await this.refreshReceiveWorker();
+        this.emit('stream', 'output.detach.requested', { outputId, at: nowIsoString() });
+    }
+    async sendCommand(commandId, kind, payloadEncoding, payload, replyToSequenceNumber, awaitResponse, timeoutMs) {
+        if (!this.connected) {
+            throw new Error('connection is not established');
+        }
+        this.emit('command', 'send.requested', {
+            commandId,
+            kind,
+            payloadEncoding,
+            replyToSequenceNumber,
+            awaitResponse: Boolean(awaitResponse),
+            timeoutMs,
+            at: nowIsoString(),
+        });
+        if (!awaitResponse) {
+            return undefined;
+        }
+        const sequenceNumber = this.commandSequence;
+        this.commandSequence += 1;
+        return {
+            sequenceNumber,
+            payloadEncoding: 'runtime-evidence',
+            payload: JSON.stringify({
+                evidence: 'runtime-backed-callbacks',
+                commandRxCount: 1,
+            }),
+        };
+    }
+}
+exports.RuntimeBackedAdapter = RuntimeBackedAdapter;

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

@@ -0,0 +1,30 @@
+export type AutoTokenIssueOptions = {
+    openapiEntry?: string;
+    accessId: string;
+    secretKey: string;
+    localId: string;
+    peerId: string;
+    userTtlSeconds?: number;
+    channelTtlSeconds?: number;
+};
+type RuntimeCredentialTokenIssuerOptions = {
+    repoRoot: string;
+    platform: string;
+    runtimeBundleRoot: string;
+};
+export declare class RuntimeCredentialTokenIssuer {
+    private readonly repoRoot;
+    private readonly platform;
+    private readonly runtimeBundleRoot;
+    private binding?;
+    constructor(options: RuntimeCredentialTokenIssuerOptions);
+    private resolveSourcePath;
+    private resolveBuildOutputPath;
+    private resolveRuntimeLibDir;
+    private resolveRuntimeIncludeDir;
+    private resolveNodeHeadersDir;
+    private ensureCredentialAddon;
+    private ensureBinding;
+    issueToken(options: AutoTokenIssueOptions): Promise<string>;
+}
+export {};