@xopcai/xopc 0.0.411 → 0.0.413

package/dist/src/phone/cloud-phones.js

@@ -0,0 +1,141 @@
+import { PhoneError, init_contracts } from "./contracts.js";
+import { CloudAdbConnection, PhoneCloudKeyStore, parseCloudEndpoint, parseCloudPrivateKey } from "./cloud-adb.js";
+import { CloudScrcpyProvider } from "./cloud-scrcpy.js";
+import { randomUUID } from "node:crypto";
+import sharp from "sharp";
+//#region src/phone/cloud-phones.ts
+init_contracts();
+var CloudPhones = class {
+	drafts = /* @__PURE__ */ new Map();
+	connections = /* @__PURE__ */ new Map();
+	constructor(repository, keys = new PhoneCloudKeyStore(), connect = (endpoint, key) => new CloudAdbConnection(endpoint, key)) {
+		this.repository = repository;
+		this.keys = keys;
+		this.connect = connect;
+	}
+	discard(token) {
+		const draft = this.drafts.get(token);
+		if (draft) {
+			clearTimeout(draft.timer);
+			draft.key.fill(0);
+			this.drafts.delete(token);
+		}
+	}
+	async test(owner, address, pem, signal) {
+		if (this.drafts.size >= 10) throw new PhoneError("PHONE_SETUP_BUSY", "Too many pending phone connections. Try again later.", 409);
+		const { endpoint } = parseCloudEndpoint(address);
+		const key = parseCloudPrivateKey(pem);
+		let lease;
+		try {
+			lease = this.repository.acquire(endpoint);
+		} catch (error) {
+			key.fill(0);
+			throw error;
+		}
+		const connection = this.connect(endpoint, Buffer.from(key));
+		try {
+			const command = (...args) => connection.command("", [
+				"-s",
+				endpoint,
+				...args
+			], signal, 2e4);
+			const model = (await command("shell", "getprop", "ro.product.model")).toString().trim().slice(0, 100);
+			const androidVersion = (await command("shell", "getprop", "ro.build.version.release")).toString().trim().slice(0, 50);
+			const pixels = await command("exec-out", "screencap", "-p");
+			let screenshot;
+			try {
+				screenshot = `data:image/jpeg;base64,${(await sharp(pixels, { limitInputPixels: 16e6 }).resize({
+					width: 360,
+					withoutEnlargement: true
+				}).jpeg({ quality: 70 }).toBuffer()).toString("base64")}`;
+			} finally {
+				pixels.fill(0);
+			}
+			signal.throwIfAborted();
+			const token = randomUUID();
+			const expiresAt = Date.now() + 6e5;
+			const timer = setTimeout(() => this.discard(token), 6e5);
+			timer.unref();
+			this.drafts.set(token, {
+				owner,
+				endpoint,
+				key: Buffer.from(key),
+				expiresAt,
+				timer
+			});
+			return {
+				token,
+				expiresAt,
+				model,
+				androidVersion,
+				screenshot,
+				endpoint,
+				media: "snapshot"
+			};
+		} finally {
+			key.fill(0);
+			connection.dispose();
+			this.repository.release(endpoint, lease);
+		}
+	}
+	async add(owner, token, name, makeDefault) {
+		const draft = this.drafts.get(token);
+		if (!draft || draft.owner !== owner || draft.expiresAt < Date.now()) throw new PhoneError("PHONE_SETUP_EXPIRED", "Connection test expired. Test the connection again.", 409);
+		this.drafts.delete(token);
+		clearTimeout(draft.timer);
+		let credentialId;
+		try {
+			credentialId = await this.keys.save(draft.key);
+			const device = this.repository.save({
+				serial: draft.endpoint,
+				name,
+				enabled: true,
+				allowedApps: ["com.android.settings"],
+				connection: {
+					kind: "aliyun-adb",
+					endpoint: draft.endpoint,
+					credentialId
+				}
+			});
+			if (makeDefault || !this.repository.defaultDevice()) this.repository.setDefault(device.id);
+			return device;
+		} catch (error) {
+			if (credentialId) await this.keys.remove(credentialId);
+			throw error;
+		} finally {
+			draft.key.fill(0);
+		}
+	}
+	cancel(owner, token) {
+		if (this.drafts.get(token)?.owner === owner) this.discard(token);
+	}
+	async driver(device) {
+		const binding = device.connection;
+		if (!binding) throw new PhoneError("PHONE_CONNECTION_INVALID", "Missing cloud connection");
+		let connection = this.connections.get(device.id);
+		if (!connection) {
+			connection = this.connect(binding.endpoint, await this.keys.load(binding.credentialId));
+			this.connections.set(device.id, connection);
+		}
+		return connection.driver();
+	}
+	async interactive(device, failed) {
+		const binding = device.connection;
+		if (!binding) throw new PhoneError("PHONE_CONNECTION_INVALID", "Missing cloud connection");
+		return new CloudScrcpyProvider(binding.endpoint, await this.keys.load(binding.credentialId), failed, this.connect);
+	}
+	disconnect(id) {
+		this.connections.get(id)?.dispose();
+		this.connections.delete(id);
+	}
+	async remove(device) {
+		this.disconnect(device.id);
+		if (device.connection) await this.keys.remove(device.connection.credentialId);
+	}
+	close() {
+		for (const token of this.drafts.keys()) this.discard(token);
+		for (const id of this.connections.keys()) this.disconnect(id);
+	}
+};
+//#endregion
+export { CloudPhones };

package/dist/src/phone/cloud-scrcpy.d.ts

@@ -0,0 +1,20 @@
+import { CloudAdbConnection } from './cloud-adb.js';
+import { ScrcpyProvider } from './scrcpy.js';
+/** Dedicated authenticated ADB transport: no host ADB key, server or port forwarding. */
+export declare class CloudScrcpyProvider extends ScrcpyProvider {
+    private endpoint;
+    private connection;
+    private process?;
+    private video?;
+    private control?;
+    private writer?;
+    private remote;
+    private scid;
+    constructor(endpoint: string, key: Buffer, onFailure: () => void, connect?: (address: string, credential: Buffer) => CloudAdbConnection);
+    foreground(signal: AbortSignal): Promise<string>;
+    protected startTransport(): Promise<void>;
+    private drain;
+    private readVideo;
+    protected write(buffer: Buffer): Promise<void>;
+    protected cleanup(): Promise<void>;
+}

package/dist/src/phone/cloud-scrcpy.js

@@ -0,0 +1,122 @@
+import { PhoneError, init_contracts } from "./contracts.js";
+import { SCRCPY_VERSION } from "../runtime-tools/phone-dependency-catalog.js";
+import { ScrcpyProvider, ScrcpyVideoParser, readScrcpyServer } from "./scrcpy.js";
+import { CloudAdbConnection } from "./cloud-adb.js";
+import { randomBytes } from "node:crypto";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import { ReadableStream } from "@yume-chan/stream-extra";
+//#region src/phone/cloud-scrcpy.ts
+init_contracts();
+/** Dedicated authenticated ADB transport: no host ADB key, server or port forwarding. */
+var CloudScrcpyProvider = class extends ScrcpyProvider {
+	connection;
+	process;
+	video;
+	control;
+	writer;
+	remote = "";
+	scid = "";
+	constructor(endpoint, key, onFailure, connect = (address, credential) => new CloudAdbConnection(address, credential)) {
+		super(onFailure);
+		this.endpoint = endpoint;
+		this.connection = connect(endpoint, key);
+	}
+	foreground(signal) {
+		return this.connection.driver().foreground(this.endpoint, signal);
+	}
+	async startTransport() {
+		const timer = setTimeout(() => this.connection.close(), 2e4);
+		try {
+			const binary = await readScrcpyServer();
+			const adb = await this.connection.client();
+			if (this.closing) throw new Error("Video closed");
+			this.scid = (randomBytes(4).readUInt32BE() & 2147483647).toString(16);
+			const socketName = `scrcpy_${this.scid.padStart(8, "0")}`;
+			this.remote = `/data/local/tmp/xopc-${socketName}.jar`;
+			const sync = await adb.sync();
+			try {
+				await sync.write({
+					filename: this.remote,
+					permission: 384,
+					file: new ReadableStream({ start(controller) {
+						controller.enqueue(binary);
+						controller.close();
+					} })
+				});
+			} finally {
+				await sync.dispose();
+			}
+			if (this.closing) throw new Error("Video closed");
+			this.process = await adb.createSocket(`exec:CLASSPATH=${this.remote} app_process / com.genymobile.scrcpy.Server ${SCRCPY_VERSION} scid=${this.scid} tunnel_forward=true audio=false control=true cleanup=false max_size=960 max_fps=30 video_bit_rate=2000000 video_codec=h264 video_codec_options=i-frame-interval=1 send_dummy_byte=false send_device_meta=false send_codec_meta=true send_frame_meta=true clipboard_autosync=false`);
+			this.drain(this.process);
+			for (let attempt = 0; attempt < 60; attempt++) {
+				if (this.closing) throw new Error("Video closed");
+				try {
+					this.video = await adb.createSocket(`localabstract:${socketName}`);
+					break;
+				} catch {
+					await setTimeout$1(50);
+				}
+			}
+			if (!this.video) throw new Error("Scrcpy connection timed out");
+			this.control = await adb.createSocket(`localabstract:${socketName}`);
+			this.writer = this.control.writable.getWriter();
+			this.drain(this.control);
+			this.readVideo(this.video);
+		} finally {
+			clearTimeout(timer);
+		}
+	}
+	async drain(socket) {
+		try {
+			for await (const _chunk of socket.readable);
+		} catch {}
+		if (!this.closing) this.fail();
+	}
+	async readVideo(socket) {
+		const parser = new ScrcpyVideoParser();
+		try {
+			for await (const chunk of socket.readable) parser.push(Buffer.from(chunk), (packet) => this.packet(packet));
+		} catch {}
+		if (!this.closing) this.fail();
+	}
+	async write(buffer) {
+		if (!this.writer) throw new PhoneError("PHONE_INPUT_DISCONNECTED", "Cloud phone input channel unavailable");
+		const timer = setTimeout(() => this.connection.close(), 2e3);
+		try {
+			await this.writer.write(buffer);
+		} finally {
+			clearTimeout(timer);
+		}
+	}
+	async cleanup() {
+		try {
+			await this.revoke().catch(() => {});
+			this.writer?.releaseLock();
+			this.writer = void 0;
+			await Promise.allSettled([
+				this.video?.close(),
+				this.control?.close(),
+				this.process?.close()
+			]);
+			if (this.scid) {
+				const command = (...args) => this.connection.command("", [
+					"-s",
+					this.endpoint,
+					"shell",
+					...args
+				], void 0, 3e3);
+				const processes = await command("ps", "-A", "-o", "PID,ARGS").catch(() => Buffer.alloc(0));
+				for (const line of processes.toString().split("\n")) {
+					const pid = /^\s*(\d+)\s+/.exec(line)?.[1];
+					if (pid && line.includes("com.genymobile.scrcpy.Server ") && new RegExp(`(?:^|\\s)scid=${this.scid}(?:\\s|$)`).test(line)) await command("kill", "-TERM", pid).catch(() => {});
+				}
+				if (this.remote) await command("rm", "-f", this.remote).catch(() => {});
+			}
+		} finally {
+			this.connection.dispose();
+		}
+	}
+};
+//#endregion
+export { CloudScrcpyProvider };

package/dist/src/phone/contracts.d.ts

@@ -0,0 +1,204 @@
+import { z } from 'zod';
+export declare const PhoneProfileSchema: z.ZodEnum<{
+    "autoglm-phone-v1": "autoglm-phone-v1";
+    "structured-phone-v1": "structured-phone-v1";
+}>;
+export declare const PhoneModelMetadataSchema: z.ZodObject<{
+    profile: z.ZodEnum<{
+        "autoglm-phone-v1": "autoglm-phone-v1";
+        "structured-phone-v1": "structured-phone-v1";
+    }>;
+}, z.core.$strict>;
+export declare const MOCK_PHONE_MODEL = "phone-mock/settings-about";
+export declare const MOCK_PHONE_GOAL = "Open Android Settings and inspect About phone";
+export declare const PhoneConfigSchema: z.ZodPrefault<z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    adbPath: z.ZodOptional<z.ZodString>;
+    maxActionsPerSession: z.ZodDefault<z.ZodNumber>;
+    maxModelRequests: z.ZodDefault<z.ZodNumber>;
+    maxOperationDurationMs: z.ZodDefault<z.ZodNumber>;
+    maxSessionDurationMs: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>>;
+export type PhoneConfig = z.infer<typeof PhoneConfigSchema>;
+export declare const PhoneDeviceSchema: z.ZodObject<{
+    id: z.ZodString;
+    serial: z.ZodString;
+    name: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    allowedApps: z.ZodArray<z.ZodString>;
+    connection: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodLiteral<"aliyun-adb">;
+        endpoint: z.ZodString;
+        credentialId: z.ZodString;
+    }, z.core.$strict>>;
+    createdAt: z.ZodNumber;
+    revision: z.ZodNumber;
+}, z.core.$strict>;
+export type PhoneDevice = z.infer<typeof PhoneDeviceSchema>;
+export type DiscoveredPhone = {
+    serial: string;
+    state: string;
+    name: string;
+    emulator: boolean;
+};
+export declare const PhoneActionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"launch">;
+    package: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"tap">;
+    point: z.ZodArray<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"doubleTap">;
+    point: z.ZodArray<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"longPress">;
+    point: z.ZodArray<z.ZodNumber>;
+    durationMs: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"swipe">;
+    start: z.ZodArray<z.ZodNumber>;
+    end: z.ZodArray<z.ZodNumber>;
+    durationMs: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"typeText">;
+    text: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodEnum<{
+        home: "home";
+        back: "back";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"wait">;
+    durationMs: z.ZodNumber;
+}, z.core.$strict>], "type">;
+export type PhoneAction = z.infer<typeof PhoneActionSchema>;
+export declare const PhoneDecisionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"action">;
+    action: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"launch">;
+        package: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"tap">;
+        point: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"doubleTap">;
+        point: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"longPress">;
+        point: z.ZodArray<z.ZodNumber>;
+        durationMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"swipe">;
+        start: z.ZodArray<z.ZodNumber>;
+        end: z.ZodArray<z.ZodNumber>;
+        durationMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"typeText">;
+        text: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodEnum<{
+            home: "home";
+            back: "back";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"wait">;
+        durationMs: z.ZodNumber;
+    }, z.core.$strict>], "type">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"complete">;
+    summary: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"needsUser">;
+    reason: z.ZodString;
+}, z.core.$strict>], "kind">;
+export type PhoneDecision = z.infer<typeof PhoneDecisionSchema>;
+export type PhoneElement = {
+    text: string;
+    description: string;
+    resourceId: string;
+    clickable: boolean;
+    focused: boolean;
+    password: boolean;
+    editable?: boolean;
+    bounds: [number, number, number, number];
+};
+export type PhoneObservation = {
+    frameId: string;
+    capturedAt: number;
+    width: number;
+    height: number;
+    rotation: number;
+    package: string;
+    frame: Buffer;
+    elements: PhoneElement[];
+};
+export declare const PhoneInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    op: z.ZodLiteral<"discover">;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodLiteral<"open">;
+    deviceId: z.ZodOptional<z.ZodString>;
+    mode: z.ZodEnum<{
+        observe: "observe";
+        control: "control";
+    }>;
+    appPackage: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodLiteral<"observe">;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodEnum<{
+        run: "run";
+        step: "step";
+    }>;
+    goal: z.ZodString;
+    scenario: z.ZodOptional<z.ZodLiteral<"settings-about">>;
+    expectText: z.ZodOptional<z.ZodString>;
+    maxActions: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodEnum<{
+        cancel: "cancel";
+        status: "status";
+        close: "close";
+        pause: "pause";
+        resume: "resume";
+    }>;
+}, z.core.$strict>], "op">;
+export type PhoneInput = z.infer<typeof PhoneInputSchema>;
+export type PhoneStatus = 'ready' | 'running' | 'paused' | 'needs_user' | 'completed' | 'cancelled' | 'closed' | 'failed' | 'outcome_unknown';
+export type PhoneReport = {
+    sessionId: string;
+    deviceId: string;
+    deviceName: string;
+    owner: string;
+    agentId: string;
+    modelRef: string;
+    mock: boolean;
+    mode: 'observe' | 'control';
+    status: PhoneStatus;
+    actions: number;
+    humanActions?: number;
+    modelRequests: number;
+    createdAt: number;
+    updatedAt: number;
+    verified: boolean;
+    verificationLevel: 'none' | 'ui';
+    stopReason?: string;
+    errorCode?: string;
+    facts?: string[];
+    foregroundApp?: string;
+    message?: string;
+    steps: Array<{
+        action: PhoneAction['type'];
+        at: number;
+        dispatch: 'completed' | 'unknown';
+        actor?: 'agent' | 'human';
+    }>;
+    controlOwner?: 'agent' | 'human' | 'none';
+    controlEpoch?: number;
+    handoff?: 'idle' | 'acquiring' | 'returning';
+    currentAction?: PhoneAction['type'];
+};
+export declare class PhoneError extends Error {
+    readonly code: string;
+    readonly status: 400 | 403 | 404 | 409 | 500 | 502;
+    constructor(code: string, message: string, status?: 400 | 403 | 404 | 409 | 500 | 502);
+}

package/dist/src/phone/contracts.js

@@ -0,0 +1,115 @@
+import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
+import { z } from "zod";
+//#region src/phone/contracts.ts
+var PhoneProfileSchema, PhoneModelMetadataSchema, MOCK_PHONE_MODEL, MOCK_PHONE_GOAL, PhoneConfigSchema, PhoneDeviceSchema, Point, PhoneActionSchema, PhoneDecisionSchema, PhoneInputSchema, PhoneError;
+var init_contracts = __esmMin((() => {
+	PhoneProfileSchema = z.enum(["autoglm-phone-v1", "structured-phone-v1"]);
+	PhoneModelMetadataSchema = z.object({ profile: PhoneProfileSchema }).strict();
+	MOCK_PHONE_MODEL = "phone-mock/settings-about";
+	MOCK_PHONE_GOAL = "Open Android Settings and inspect About phone";
+	PhoneConfigSchema = z.object({
+		enabled: z.boolean().default(false),
+		adbPath: z.string().min(1).optional(),
+		maxActionsPerSession: z.number().int().min(1).max(80).default(40),
+		maxModelRequests: z.number().int().min(1).max(120).default(60),
+		maxOperationDurationMs: z.number().int().min(1e3).max(9e5).default(3e5),
+		maxSessionDurationMs: z.number().int().min(1e3).max(9e5).default(9e5)
+	}).strict().prefault({});
+	PhoneDeviceSchema = z.object({
+		id: z.string().uuid(),
+		serial: z.string().min(1).max(200),
+		name: z.string().trim().min(1).max(100),
+		enabled: z.boolean().default(true),
+		allowedApps: z.array(z.string().regex(/^[a-zA-Z][\w]*(?:\.[\w]+)+$/)).min(1).max(50),
+		connection: z.object({
+			kind: z.literal("aliyun-adb"),
+			endpoint: z.string().max(200),
+			credentialId: z.string().uuid()
+		}).strict().optional(),
+		createdAt: z.number(),
+		revision: z.number().int().positive()
+	}).strict();
+	Point = z.array(z.number().finite().min(0).max(1e3)).length(2);
+	PhoneActionSchema = z.discriminatedUnion("type", [
+		z.object({
+			type: z.literal("launch"),
+			package: z.string().regex(/^[a-zA-Z][\w]*(?:\.[\w]+)+$/)
+		}).strict(),
+		z.object({
+			type: z.literal("tap"),
+			point: Point
+		}).strict(),
+		z.object({
+			type: z.literal("doubleTap"),
+			point: Point
+		}).strict(),
+		z.object({
+			type: z.literal("longPress"),
+			point: Point,
+			durationMs: z.number().int().min(100).max(3e3).default(800)
+		}).strict(),
+		z.object({
+			type: z.literal("swipe"),
+			start: Point,
+			end: Point,
+			durationMs: z.number().int().min(100).max(2e3).default(500)
+		}).strict(),
+		z.object({
+			type: z.literal("typeText"),
+			text: z.string().min(1).max(4e3)
+		}).strict(),
+		z.object({ type: z.enum(["back", "home"]) }).strict(),
+		z.object({
+			type: z.literal("wait"),
+			durationMs: z.number().int().min(100).max(3e3)
+		}).strict()
+	]);
+	PhoneDecisionSchema = z.discriminatedUnion("kind", [
+		z.object({
+			kind: z.literal("action"),
+			action: PhoneActionSchema
+		}).strict(),
+		z.object({
+			kind: z.literal("complete"),
+			summary: z.string().max(1e3)
+		}).strict(),
+		z.object({
+			kind: z.literal("needsUser"),
+			reason: z.string().max(1e3)
+		}).strict()
+	]);
+	PhoneInputSchema = z.discriminatedUnion("op", [
+		z.object({ op: z.literal("discover") }).strict(),
+		z.object({
+			op: z.literal("open"),
+			deviceId: z.string().uuid().optional(),
+			mode: z.enum(["observe", "control"]),
+			appPackage: z.string().regex(/^[a-zA-Z][\w]*(?:\.[\w]+)+$/).optional()
+		}).strict(),
+		z.object({ op: z.literal("observe") }).strict(),
+		z.object({
+			op: z.enum(["run", "step"]),
+			goal: z.string().trim().min(1).max(2e3),
+			scenario: z.literal("settings-about").optional(),
+			expectText: z.string().min(1).max(200).optional(),
+			maxActions: z.number().int().min(1).max(12).default(6)
+		}).strict(),
+		z.object({ op: z.enum([
+			"status",
+			"pause",
+			"resume",
+			"cancel",
+			"close"
+		]) }).strict()
+	]);
+	PhoneError = class extends Error {
+		constructor(code, message, status = 400) {
+			super(message);
+			this.code = code;
+			this.status = status;
+		}
+	};
+}));
+//#endregion
+init_contracts();
+export { MOCK_PHONE_GOAL, MOCK_PHONE_MODEL, PhoneActionSchema, PhoneConfigSchema, PhoneDecisionSchema, PhoneDeviceSchema, PhoneError, PhoneInputSchema, PhoneModelMetadataSchema, PhoneProfileSchema, init_contracts };

package/dist/src/phone/interactive-session.d.ts

@@ -0,0 +1,34 @@
+import type { PhoneInteractiveProvider, PhonePointer, PhoneVideoPacket } from './live-provider.js';
+/** Shared device source with bounded video gating and ordered, fenced input. */
+export declare class PhoneInteractiveSession {
+    readonly provider: PhoneInteractiveProvider;
+    private checkScreen;
+    private authorize;
+    private onGesture;
+    private viewers;
+    private queue;
+    private pending;
+    private seq;
+    private packets;
+    private bytes;
+    private checkedAt;
+    private allowed;
+    private closed;
+    private timer?;
+    private unsubscribe?;
+    private config?;
+    private started?;
+    private gesture?;
+    private verification?;
+    constructor(provider: PhoneInteractiveProvider, checkScreen: () => Promise<void>, authorize: (client: string, epoch: number) => void, onGesture?: (action: 'tap' | 'longPress' | 'swipe') => void);
+    start(): Promise<void>;
+    private verifyScreen;
+    private poll;
+    subscribe(client: string, packet: (packet: PhoneVideoPacket) => void, fault: (code: string) => void): () => void;
+    input(client: string, input: PhonePointer): Promise<void>;
+    revoke(): Promise<void>;
+    close(): Promise<void>;
+    get viewerCount(): number;
+    verifyGeometry(version: number): boolean;
+    authorizeClient(client: string, epoch: number): void;
+}