@modelprofile.com/browser-runtime 5.0.0 → 5.2.0

package/ts/classes.runtime.ts

@@ -29,6 +29,8 @@ import type {
   IBrowserResourceRegistration,
   IBrowserRuntimeState,
   IBrowserRuntimeViewportResult,
+  IBrowserRuntimeEventSubscriptionOptions,
+  TBrowserRuntimeVideoOffer,
   IBrowserScreenshotResult,
   ICreateBrowserResourceRequest,
   TQualifiedBrowserSessionId,
@@ -102,6 +104,7 @@ interface INormalizedRuntimeOptions {
   maxOutstandingFrames: number;
   frameAcknowledgementTimeoutMs: number;
   screencast: INormalizedScreencastOptions;
+  video: Required<plugins.smartpuppeteer.ILiveVideoOptions>;
   egress: NonNullable<IBrowserRuntimeOptions['egress']>;
   ownership?: IBrowserRuntimeTestingOptions['ownership'];
   beforeLeasePublication?: IBrowserRuntimeTestingOptions['beforeLeasePublication'];
@@ -138,6 +141,9 @@ interface ILeaseRecord {
   released: boolean;
   releasePromise?: Promise<void>;
   preferredViewport?: plugins.smartpuppeteer.ILiveBrowserViewport;
+  videoPeerId: string;
+  videoPeerMayExist: boolean;
+  frameCaptureUsed: boolean;
   heldKeys: Map<string, plugins.smartpuppeteer.ILiveBrowserKeyInput>;
   heldButtons: Map<string, plugins.smartpuppeteer.ILiveBrowserMouseInput>;
 }
@@ -175,7 +181,7 @@ interface IQueuedOperationRecord {
   state: 'queued' | 'starting' | 'active' | 'settled';
   onQueuedAbort?: () => void;
   /** Resource-owned cleanup, admitted only for this exact released participant. */
-  participantCleanup?: boolean;
+  participantCleanup?: 'participant' | 'subscription' | false;
 }
 
 interface IOutstandingFrameRecord {
@@ -194,6 +200,10 @@ type TFrameAcknowledgementOutcome =
 interface IFrameSubscriptionRecord {
   lease: ILeaseRecord;
   listener: (event: TBrowserRuntimeEvent) => void;
+  includeFrames: boolean;
+  session: ILiveBrowserSessionLike;
+  closePromise?: Promise<void>;
+  closeComplete?: boolean;
   outstanding: Map<string, IOutstandingFrameRecord>;
   highestSequence: number;
   closed: boolean;
@@ -240,6 +250,7 @@ interface IResourceSlot {
   operationQueue: IQueuedOperationRecord[];
   operationSchedulerRunning: boolean;
   frameSubscriptions: Map<string, IFrameSubscriptionRecord>;
+  frameCaptureEnabled?: boolean;
   highestFrameSequence: number;
   producerAcknowledgements: Set<Promise<TFrameAcknowledgementOutcome>>;
   frameRefresh?: IFrameRefreshRecord;
@@ -558,6 +569,7 @@ export class BrowserRuntime {
         10_000,
       ),
       screencast,
+      video: plugins.smartpuppeteer.normalizeLiveVideoOptions(options.video ?? {}),
       egress: options.egress ?? {},
       ownership: testingOptions?.ownership,
       beforeLeasePublication: testingOptions?.beforeLeasePublication,
@@ -1352,6 +1364,46 @@ export class BrowserRuntime {
       });
   }
 
+  /** @internal */
+  public async leaseOpenVideoPeer(lease: ILeaseRecord, options: IBrowserRuntimeOperationOptions = {}): Promise<TBrowserRuntimeVideoOffer> {
+    this.requireHuman(lease);
+    return this.runOperation(lease, 'openVideoPeer', 'video-peer', options, async (signal, session) => {
+      lease.videoPeerMayExist = true;
+      const { peerId: _peerId, ...offer } = await session.openVideoPeer(lease.videoPeerId, { signal });
+      return offer;
+    });
+  }
+
+  /** @internal */
+  public async leaseAnswerVideoPeer(lease: ILeaseRecord, negotiationId: string,
+    description: plugins.smartpuppeteer.ILiveVideoDescription, options: IBrowserRuntimeOperationOptions = {}): Promise<void> {
+    this.requireHuman(lease);
+    const id = validateBoundedString(negotiationId, 'negotiationId', 1, 128);
+    if (id !== negotiationId) throw new BrowserRuntimeError('INVALID_INPUT');
+    const record = validateExactKeys(description, ['type', 'sdp'], 'video answer');
+    const answer = { type: record.type, sdp: record.sdp } as plugins.smartpuppeteer.ILiveVideoDescription;
+    try { plugins.smartpuppeteer.validateLiveVideoDescription(answer, 'answer'); }
+    catch { throw new BrowserRuntimeError('INVALID_INPUT'); }
+    return this.runOperation(lease, 'answerVideoPeer', 'video-peer', options,
+      async (signal, session) => session.answerVideoPeer(lease.videoPeerId, id, answer, { signal }));
+  }
+
+  /** @internal */
+  public async leaseCloseVideoPeer(lease: ILeaseRecord, options: IBrowserRuntimeOperationOptions = {}): Promise<void> {
+    this.requireHuman(lease);
+    return this.runOperation(lease, 'closeVideoPeer', 'video-peer', options, async (_signal, session) => {
+      await session.closeVideoPeer(lease.videoPeerId);
+      lease.videoPeerMayExist = false;
+    });
+  }
+
+  /** @internal */
+  public async leaseGetVideoStatistics(lease: ILeaseRecord, options: IBrowserRuntimeOperationOptions = {}): Promise<plugins.smartpuppeteer.ILiveVideoStatistics> {
+    this.requireHuman(lease);
+    return this.runOperation(lease, 'getVideoStatistics', 'video-peer', options,
+      async (_signal, session) => session.getVideoStatistics(lease.videoPeerId));
+  }
+
   private validatePreferredViewport(
     value: plugins.smartpuppeteer.ILiveBrowserViewport,
   ): plugins.smartpuppeteer.ILiveBrowserViewport {
@@ -1402,7 +1454,7 @@ export class BrowserRuntime {
     this.requireValidLease(lease);
     const slot = lease.slot;
     const subscription = slot.frameSubscriptions.get(lease.leaseId);
-    if (!subscription || subscription.closed || subscription.lease !== lease) {
+    if (!subscription || subscription.closed || !subscription.includeFrames || subscription.lease !== lease) {
       throw new BrowserRuntimeError('BUSY');
     }
     let refresh: IFrameRefreshRecord | undefined;
@@ -1599,34 +1651,65 @@ export class BrowserRuntime {
   public async subscribeLeaseEvents(
     lease: ILeaseRecord,
     listener: (event: TBrowserRuntimeEvent) => void,
+    options: IBrowserRuntimeEventSubscriptionOptions = {},
   ): Promise<IBrowserRuntimeFrameSubscription> {
     this.requireHuman(lease);
     if (typeof listener !== 'function') throw new BrowserRuntimeError('INVALID_INPUT');
+    const values = validateExactKeys(options, ['includeFrames'], 'event subscription');
+    if (values.includeFrames !== undefined && typeof values.includeFrames !== 'boolean') {
+      throw new BrowserRuntimeError('INVALID_INPUT');
+    }
     const slot = lease.slot;
     const release = slot.mutex.tryAcquire();
     if (!release) throw new BrowserRuntimeError('BUSY');
-    let subscription: IFrameSubscriptionRecord;
     try {
       this.requireValidLease(lease);
-      if (slot.frameSubscriptions.has(lease.leaseId)) throw new BrowserRuntimeError('BUSY');
-      subscription = {
-        lease,
-        listener,
-        outstanding: new Map(),
-        highestSequence: 0,
-        closed: false,
-      };
-      slot.frameSubscriptions.set(lease.leaseId, subscription);
-      this.pushToSubscription(subscription, {
-        type: 'state',
-        state: this.resourceState(slot.session!.getState()),
+      if (values.includeFrames === false) {
+        if (slot.frameSubscriptions.has(lease.leaseId)) throw new BrowserRuntimeError('BUSY');
+        const subscription: IFrameSubscriptionRecord = {
+          lease, listener, includeFrames: false, session: slot.session!,
+          outstanding: new Map(), highestSequence: 0, closed: false,
+        };
+        slot.frameSubscriptions.set(lease.leaseId, subscription);
+        this.pushToSubscription(subscription, { type: 'state', state: this.resourceState(slot.session!.getState()) });
+        return { close: () => this.closeFrameSubscription(subscription) };
+      }
+    } finally { release(); }
+    let subscription: IFrameSubscriptionRecord | undefined;
+    try {
+      return await this.runOperation(lease, 'subscribeEvents', 'frame-stream', {}, async (signal, session) => {
+        if (slot.frameSubscriptions.has(lease.leaseId)) throw new BrowserRuntimeError('BUSY');
+        subscription = {
+          lease, listener, includeFrames: values.includeFrames !== false, session,
+          outstanding: new Map(), highestSequence: 0, closed: false,
+        };
+        slot.frameSubscriptions.set(lease.leaseId, subscription);
+        if (subscription.includeFrames) {
+          lease.frameCaptureUsed = true;
+          await this.reconcileFrameCapture(slot, session, signal);
+        }
+        this.pushToSubscription(subscription, { type: 'state', state: this.resourceState(session.getState()) });
+        const ownedSubscription = subscription;
+        return { close: () => this.closeFrameSubscription(ownedSubscription) };
       });
-    } finally {
-      release();
+    } catch (error) {
+      if (subscription) {
+        this.detachFrameSubscription(subscription);
+        await this.revokeCapabilityRecord(lease.capability);
+      }
+      throw error;
     }
-    return {
-      close: async () => this.closeFrameSubscription(subscription),
-    };
+  }
+
+  private async reconcileFrameCapture(slot: IResourceSlot, session: ILiveBrowserSessionLike, signal: AbortSignal): Promise<void> {
+    const enabled = [...slot.frameSubscriptions.values()].some((subscription) => (
+      !subscription.closed && !subscription.lease.released && subscription.includeFrames
+    ));
+    if (slot.frameCaptureEnabled === enabled) return;
+    // A failed/aborted CDP transition may have reached the browser; cleanup must reconcile it.
+    slot.frameCaptureEnabled = undefined;
+    await session.setFrameCaptureEnabled(enabled, { signal });
+    slot.frameCaptureEnabled = enabled;
   }
 
   /** @internal */
@@ -1649,23 +1732,30 @@ export class BrowserRuntime {
     lease: ILeaseRecord,
     artifactId: string,
   ): Promise<Uint8Array> {
-    this.requireHuman(lease);
     this.requireValidLease(lease);
-    return this.requireArtifactStore().read(
+    const bytes = await this.requireArtifactStore().read(
       lease.capability.projectId,
       lease.capability.browserResourceId,
       artifactId,
+      lease.role === 'agent' ? lease.leaseId : undefined,
     );
+    try {
+      this.requireValidLease(lease);
+      return bytes;
+    } catch (errorArg) {
+      bytes.fill(0);
+      throw errorArg;
+    }
   }
 
   /** @internal */
   public async deleteLeaseArtifact(lease: ILeaseRecord, artifactId: string): Promise<void> {
-    this.requireHuman(lease);
     this.requireValidLease(lease);
     await this.requireArtifactStore().delete(
       lease.capability.projectId,
       lease.capability.browserResourceId,
       artifactId,
+      lease.role === 'agent' ? lease.leaseId : undefined,
     );
   }
 
@@ -1884,6 +1974,9 @@ export class BrowserRuntime {
       controller: new AbortController(),
       authorityGeneration: slot.authorityGeneration,
       released: false,
+      videoPeerId: randomId(24),
+      videoPeerMayExist: false,
+      frameCaptureUsed: false,
       heldKeys: new Map(),
       heldButtons: new Map(),
     };
@@ -1919,8 +2012,9 @@ export class BrowserRuntime {
         forceNoSandbox: false,
         usePipe: true,
         allowEvaluation: true,
+        video: this.options.video,
         screencast: {
-          maxOutstandingFrames: this.options.maxOutstandingFrames,
+          enabled: false,          maxOutstandingFrames: this.options.maxOutstandingFrames,
           quality: this.options.screencast.quality,
           maxWidth: this.options.screencast.maxWidth,
           maxHeight: this.options.screencast.maxHeight,
@@ -1938,7 +2032,6 @@ export class BrowserRuntime {
             '--disable-quic',
             '--disable-dns-prefetch',
             '--disable-background-networking',
-            '--disable-extensions',
             '--webrtc-ip-handling-policy=disable_non_proxied_udp',
             '--host-resolver-rules=MAP * ~NOTFOUND, EXCLUDE 127.0.0.1',
           ],
@@ -1991,6 +2084,7 @@ export class BrowserRuntime {
       }
       if (probeSignal.aborted) throw probeSignal.reason;
       slot.session = session;
+      slot.frameCaptureEnabled = false;
       slot.proxy = proxy;
       slot.profileDirectory = profileDirectory;
       slot.unsubscribeSession = unsubscribe;
@@ -2052,7 +2146,7 @@ export class BrowserRuntime {
     operationOptions: IBrowserRuntimeOperationOptions,
     execute: (signal: AbortSignal, session: ILiveBrowserSessionLike) => Promise<T>,
     finalize?: () => Promise<void>,
-    participantCleanup = false,
+    participantCleanup: 'participant' | 'subscription' | false = false,
   ): Promise<T> {
     if (!operationOptions || typeof operationOptions !== 'object') {
       throw new BrowserRuntimeError('INVALID_INPUT');
@@ -2564,6 +2658,7 @@ export class BrowserRuntime {
           lease.capability.browserResourceId,
           snapshot.mimeType,
           snapshot.data,
+          lease.leaseId,
         );
         return { action: 'screenshot', artifact } satisfies IBrowserScreenshotResult;
       } finally {
@@ -2614,6 +2709,7 @@ export class BrowserRuntime {
 
   private resourceState(state: plugins.smartpuppeteer.ILiveBrowserState): IBrowserRuntimeState {
     return {
+      ...(state.videoAcceleration ? { videoAcceleration: { ...state.videoAcceleration } } : {}),
       status: state.status,
       activeTabId: state.activeTabId ? truncateString(state.activeTabId, 128) : null,
       viewportRevision: state.viewportRevision,
@@ -2657,6 +2753,7 @@ export class BrowserRuntime {
       slot.frameRefresh
       || slot.frameSubscriptions.get(lease.leaseId) !== subscription
       || subscription.closed
+      || !subscription.includeFrames
       || subscription.lease !== lease
       || slot.leases.get(lease.leaseId) !== lease
       || slot.session !== session
@@ -2938,6 +3035,7 @@ export class BrowserRuntime {
       if (event.frame.data.byteLength > this.options.maxFrameBytes) {
         if (refresh) this.failFrameRefresh(refresh, 'FRAME_TOO_LARGE');
         for (const subscription of slot.frameSubscriptions.values()) {
+          if (!subscription.includeFrames) continue;
           this.pushToSubscription(subscription, {
             type: 'error',
             error: { code: 'FRAME_TOO_LARGE', fatal: false, tabId: acknowledgement.tabId },
@@ -2956,7 +3054,7 @@ export class BrowserRuntime {
       }
       const key = this.frameAcknowledgementKey(acknowledgement);
       for (const subscription of [...slot.frameSubscriptions.values()]) {
-        if (subscription.closed) continue;
+        if (subscription.closed || !subscription.includeFrames) continue;
         while (subscription.outstanding.size >= this.options.maxOutstandingFrames) {
           const oldestKey = subscription.outstanding.keys().next().value!;
           this.trackCleanup(this.retireOutstandingFrame(subscription, oldestKey).then(() => undefined));
@@ -3019,20 +3117,53 @@ export class BrowserRuntime {
       return true;
     } catch {
       // A failed participant transport cannot revoke another participant or kill the producer.
-      this.trackCleanup(this.closeFrameSubscription(subscription));
+      this.detachFrameSubscription(subscription);
       this.trackCleanup(this.revokeCapabilityRecord(subscription.lease.capability));
       return false;
     }
   }
 
   private async closeFrameSubscription(subscription: IFrameSubscriptionRecord): Promise<void> {
-    if (subscription.closed) return;
+    if (subscription.closeComplete) return;
+    if (subscription.closePromise) return subscription.closePromise;
+    this.detachFrameSubscription(subscription, false);
+    const lease = subscription.lease;
+    const slot = lease.slot;
+    const operation = (async () => {
+      if (subscription.includeFrames && slot.session === subscription.session) {
+        if (lease.released) await this.releaseLeaseRecord(lease);
+        else if (this.lifecycleState === 'running' && !slot.permanentlyFenced && !slot.retirementPending
+          && slot.fencingGeneration === undefined && slot.terminationFenceGeneration === undefined) {
+          await this.runOperation(lease, 'unsubscribeFrames', 'frame-stream', {}, async (signal, session) => {
+            await this.reconcileFrameCapture(slot, session, signal);
+            this.detachFrameSubscription(subscription);
+            subscription.closeComplete = true;
+          }, undefined, 'subscription');
+        }
+      }
+      this.detachFrameSubscription(subscription);
+      subscription.closeComplete = true;
+    })();
+    subscription.closePromise = operation;
+    try { await operation; }
+    catch (error) {
+      // Producer failure may supersede a queued unsubscribe. Its exact incarnation's
+      // confirmed termination completes capture cleanup without issuing another toggle.
+      const failure = slot.frameFailure;
+      if (failure?.session === subscription.session) await failure.promise;
+      if (slot.session === subscription.session || !lease.released) throw error;
+      this.detachFrameSubscription(subscription);
+      subscription.closeComplete = true;
+    } finally { subscription.closePromise = undefined; }
+  }
+
+  private detachFrameSubscription(subscription: IFrameSubscriptionRecord, remove = true): void {
     subscription.closed = true;
     const slot = subscription.lease.slot;
     if (slot.frameRefresh?.subscription === subscription) {
       this.abandonFrameRefresh(slot, slot.frameRefresh);
     }
-    if (slot.frameSubscriptions.get(subscription.lease.leaseId) === subscription) {
+    if (remove && slot.frameSubscriptions.get(subscription.lease.leaseId) === subscription) {
       slot.frameSubscriptions.delete(subscription.lease.leaseId);
     }
     for (const frame of subscription.outstanding.values()) {
@@ -3191,10 +3322,10 @@ export class BrowserRuntime {
     this.trackCleanup(operation);
   }
 
-  private requireQueuedLease(lease: ILeaseRecord, participantCleanup = false): void {
+  private requireQueuedLease(lease: ILeaseRecord, participantCleanup: 'participant' | 'subscription' | false = false): void {
     if (!participantCleanup) return this.requireValidLease(lease);
     if (
-      !lease.released || lease.slot.leases.get(lease.leaseId) !== lease
+      (participantCleanup === 'participant' && !lease.released) || lease.slot.leases.get(lease.leaseId) !== lease
       || lease.capability.lease !== lease || !lease.slot.session
     ) throw new BrowserRuntimeError('CAPABILITY_REVOKED');
   }
@@ -3359,14 +3490,20 @@ export class BrowserRuntime {
     if (
       this.lifecycleState === 'running' && slot.session && !slot.permanentlyFenced && !slot.retirementPending
       && slot.fencingGeneration === undefined && slot.terminationFenceGeneration === undefined
-      && (lease.preferredViewport || lease.heldKeys.size || lease.heldButtons.size)
+      && (lease.preferredViewport || lease.heldKeys.size || lease.heldButtons.size
+        || lease.videoPeerMayExist || lease.frameCaptureUsed)
     ) {
       await this.runOperation(lease, 'releaseParticipant', 'viewport', {},
         async (signal, session) => {
+          if (lease.videoPeerMayExist) {
+            await session.closeVideoPeer(lease.videoPeerId);
+            lease.videoPeerMayExist = false;
+          }
+          if (lease.frameCaptureUsed) await this.reconcileFrameCapture(slot, session, signal);
           await this.releaseParticipantInput(lease, session);
           await this.applySharedViewport(slot, session, signal);
           lease.preferredViewport = undefined;
-        }, undefined, true);
+        }, undefined, 'participant');
     }
     if (slot.permanentlyFenced && (slot.session || slot.proxy || slot.profileDirectory)) {
       await this.terminateSlotSession(slot);
@@ -3384,7 +3521,7 @@ export class BrowserRuntime {
 
   private async closeFrameSubscriptionIfLease(lease: ILeaseRecord): Promise<void> {
     const subscription = lease.slot.frameSubscriptions.get(lease.leaseId);
-    if (subscription) await this.closeFrameSubscription(subscription);
+    if (subscription) this.detachFrameSubscription(subscription);
   }
 
   private async quiesceSlot(slot: IResourceSlot): Promise<void> {
@@ -4235,8 +4372,26 @@ export class BrowserRuntimeLease {
 
   public subscribeEvents(
     listener: (event: TBrowserRuntimeEvent) => void,
+    options?: IBrowserRuntimeEventSubscriptionOptions,
   ): Promise<IBrowserRuntimeFrameSubscription> {
-    return this.runtime.subscribeLeaseEvents(this.record, listener);
+    return this.runtime.subscribeLeaseEvents(this.record, listener, options);
+  }
+
+  public openVideoPeer(options?: IBrowserRuntimeOperationOptions): Promise<TBrowserRuntimeVideoOffer> {
+    return this.runtime.leaseOpenVideoPeer(this.record, options);
+  }
+
+  public answerVideoPeer(negotiationId: string, description: plugins.smartpuppeteer.ILiveVideoDescription,
+    options?: IBrowserRuntimeOperationOptions): Promise<void> {
+    return this.runtime.leaseAnswerVideoPeer(this.record, negotiationId, description, options);
+  }
+
+  public closeVideoPeer(options?: IBrowserRuntimeOperationOptions): Promise<void> {
+    return this.runtime.leaseCloseVideoPeer(this.record, options);
+  }
+
+  public getVideoStatistics(options?: IBrowserRuntimeOperationOptions): Promise<plugins.smartpuppeteer.ILiveVideoStatistics> {
+    return this.runtime.leaseGetVideoStatistics(this.record, options);
   }
 
   public acknowledgeFrame(

package/ts/index.ts

@@ -48,6 +48,8 @@ export type {
   IBrowserRuntimeOperationOptions,
   IBrowserRuntimeOptions,
   IBrowserRuntimeScreencastOptions,
+  IBrowserRuntimeEventSubscriptionOptions,
+  TBrowserRuntimeVideoOffer,
   IBrowserResourceKey,
   IBrowserResourceRegistration,
   IBrowserRuntimeState,

package/ts/interfaces.ts

@@ -133,6 +133,7 @@ export type TBrowserRuntimeOperationIdentity = TReadonlyBrowserCapabilityAuthori
 export type TBrowserRuntimeOperationClassification =
   | 'raw-input'
   | 'frame-stream'
+  | 'video-peer'
   | 'viewport'
   | 'navigation'
   | 'tab'
@@ -167,6 +168,12 @@ export interface ILiveBrowserSessionLike {
   getState(): plugins.smartpuppeteer.ILiveBrowserState;
   getProcessState(): plugins.smartpuppeteer.ILiveBrowserProcessState;
   onEvent(listener: plugins.smartpuppeteer.TLiveBrowserEventListener): () => void;
+  setFrameCaptureEnabled(enabled: boolean, options?: plugins.smartpuppeteer.ILiveBrowserOperationOptions): Promise<void>;
+  openVideoPeer(peerId: string, options?: plugins.smartpuppeteer.ILiveBrowserOperationOptions): Promise<plugins.smartpuppeteer.ILiveVideoOffer>;
+  answerVideoPeer(peerId: string, negotiationId: string, description: plugins.smartpuppeteer.ILiveVideoDescription,
+    options?: plugins.smartpuppeteer.ILiveBrowserOperationOptions): Promise<void>;
+  closeVideoPeer(peerId: string): Promise<void>;
+  getVideoStatistics(peerId: string): Promise<plugins.smartpuppeteer.ILiveVideoStatistics>;
   refreshScreencast(
     options?: plugins.smartpuppeteer.ILiveBrowserOperationOptions,
   ): Promise<plugins.smartpuppeteer.ILiveBrowserFrameIdentity>;
@@ -291,6 +298,8 @@ export interface IBrowserRuntimeOptions {
   maxOutstandingFrames?: number;
   frameAcknowledgementTimeoutMs?: number;
   screencast?: IBrowserRuntimeScreencastOptions;
+  /** Trusted host configuration; defaults to direct ICE and automatic GPU support. */
+  video?: plugins.smartpuppeteer.ILiveVideoOptions;
   egress?: Omit<IBrowserEgressProxyOptions, 'projectId' | 'browserResourceId'>;
   artifacts?: Omit<IBrowserArtifactStoreOptions, 'rootDirectory'>;
 }
@@ -306,7 +315,15 @@ export interface IBrowserRuntimeTabState {
   streaming: boolean;
 }
 
+export interface IBrowserRuntimeEventSubscriptionOptions {
+  /** Set false for native video viewers. Defaults to true for image-frame consumers. */
+  includeFrames?: boolean;
+}
+
+export type TBrowserRuntimeVideoOffer = Omit<plugins.smartpuppeteer.ILiveVideoOffer, 'peerId'>;
+
 export interface IBrowserRuntimeState {
+  videoAcceleration?: plugins.smartpuppeteer.ILiveVideoAcceleration;
   status: 'stopped' | 'starting' | 'running' | 'stopping';
   activeTabId: string | null;
   viewportRevision: number;

package/readme.hints.md

@@ -1,60 +0,0 @@
-# readme.hints.md
-
-Durable implementation findings for `@modelprofile.com/browser-runtime`.
-
-## Ownership and lifecycle
-
-- Host-runtime liveness is owned by SmartIPC `NamedMutex` using a namespace bound to the UID and secured runtime-directory device, inode, and path hash. Its permanent private `runtime.mutex` anchor directory and file stay on the runtime directory's trusted local filesystem. Clean native contention is `LOCKED`; backend, anchor, lock, or release uncertainty is `FENCED`.
-- Persistent, fsynced `runtime.lock` metadata is a downgrade fence, not the live mutex, and is never removed by normal shutdown. Every start owns one metadata-named generation containing private profile and artifact roots.
-- Metadata-generation recovery performs no lock-descriptor scan. It removes only the exact named generation after checking every same-UID process for an absolute `--user-data-dir` equal to or below that profile root; this check is process-generic, not Chromium-specific.
-- Process ownership comes from all four `/proc/<pid>/status` `Uid:` values, not `/proc/<pid>` directory ownership. Only an exact same-UID or definite other-UID classification is actionable; mixed, unreadable, malformed, symlinked, wrongly owned/mode, hard-linked, ambiguous, or uncontained ownership state remains fenced.
-- An empty process command line triggers one status revalidation. A conclusively departed PID (both status and PID directory missing), definite other UID, or exact same-UID zombie is clear. A still-present PID with missing/unreadable status, ambiguous UID, or malformed/duplicate state remains fenced; exit between command-line and status reads does not block startup.
-- Legacy zero-byte locks alone use SmartIPC's consuming kernel probe for other read/write open descriptions. Adoption additionally requires birth, change, and modification timestamps strictly before bounded `/proc/stat` `btime`, plus no same-UID process using the exact or descendant legacy profile root. After an exclusive probe, Runtime reopens and revalidates the exact original inode, ownership, mode, link count, zero size, and timestamps. Probe contention is locked; probe or reopen uncertainty, same-boot, malformed, or ambiguous state remains fenced against the 3.2 close-before-unlink race. `O_PATH` descriptors do not contend.
-- A clean 3.2 stopped layout has no lock and may retain private empty top-level profile and artifact roots. The native-mutex winner validates, process-checks, and removes only those roots. Before metadata fsync succeeds, failure cleanup may unlink only the exact lock inode that acquisition just created; preexisting locks are never removed.
-- Shutdown attempts artifact and ownership cleanup after peer, revocation, or resource failures, retains retryable local slot state, and blocks restart until that state clears. Automatic ownership-loss cleanup gets one bounded retry; stale active metadata remains a fail-closed recovery fence.
-- Controller durable truth is a logical resource with immutable `projectId`, stable random `browserResourceId`, and a revisioned attachment binding. Runtime state is process-local and must be re-registered after every restart.
-- A resource slot owns its browser incarnation, transition mutex, generations, exact participant leases, shared bounded FIFO, independent viewer frame windows, authenticated egress proxy, private profile, and idle timer. Joining or releasing a participant does not change the resource arbitration generation.
-- `terminateResource()` and idle termination remove only the incarnation. They preserve registration, attachment, capabilities, and artifacts. `retireResource()` permanently fences, revokes, terminates, purges exact-resource artifacts, then unregisters only after all cleanup succeeds. Durable retirement remains Controller truth; Runtime tombstones are bounded and process-local.
-- Failed retirement retains a fenced, retryable registration. Unknown profile, lock, or artifact ownership remains fail closed.
-- Launch quota admission uses synchronous pending reservations across global and per-project running-resource limits.
-
-## Attachment and capability boundary
-
-- Attachment revision is independent from incarnation and arbitration generations. Equal revisions are idempotent only for an identical binding; lower or conflicting equal revisions fail.
-- Any `sessionId: null` binding is detached; revision zero is the initial detached/no-agent-authority state. Attachment transitions fence and revoke only agent authority. Human viewers keep resource access. An agent operation that cannot quiesce still requires terminating that resource's incarnation.
-- Agent capabilities require the exact current qualified session. Human issuance validates the attachment current at issuance, but subsequent human operations authorize the exact project/resource/actor/peer independently from agent attachment changes. Flex run channels use trusted pipes; independently authenticated MCP bindings support OpenCode, Codex, and Flex session IDs without impersonating a Flex run channel.
-- Capability tokens are returned once. Runtime records retain only SHA-256 digests and use `timingSafeEqual`. Authorization is rechecked after asynchronous host authorization, during lease acquisition, and before and after every operation.
-- Capability, audit, and lease identity includes immutable project, resource, attachment authority and revision, actor, peer, role, source, qualified agent session, and Flex scope/channel/run where applicable.
-- All participant operations share a resource FIFO with per-lease and aggregate bounds. A released participant's cleanup joins that same FIFO with exact retained lease identity, bypasses user-operation authorization only for resource-owned input release/viewport recomputation, and retains lifecycle cancellation and operation timeout enforcement.
-- Human frame refresh enters the shared FIFO, captures the initiating subscription, clears viewer windows, waits for producer acknowledgements, and validates one constant-sized new-generation boundary. A running open tab may refresh while streaming is false. New frames fan out to all participants.
-- `beforeOperation` reserves the exact resource and lets the host persist policy/audit through an awaited fail-closed gate. Runtime then atomically revalidates lease, attachment, session, arbitration generation, and incarnation before starting the side effect. Both host hooks carry the same exact operation ID and classification; terminal audit remains best effort and runs after bounded cleanup releases or fences the exact reservation.
-- Lease authority snapshots are immutable process-local revalidation tokens. They expose `authorityGeneration` and bind the runtime instance, incarnation, exact `capabilityId`, exact `leaseId`, and attachment, but never replace Controller durable attachment truth.
-
-- Viewport preferences are per human lease. Effective width, height and DSF use the componentwise minimum; results carry the actual viewport revision, including unchanged-size responses. Departure expands the viewport through serialized resource-owned cleanup and retains its cleanup marker until the resize succeeds, so failed cleanup remains retryable. Input ownership is bounded to 64 keys and 5 buttons per participant, and departure preserves another participant's held input.
-
-## Browser confinement
-
-- Production session options are assembled only inside `BrowserRuntime`: sandbox required, random private per-resource user data directory, one authenticated proxy per running resource, fixed network-reduction arguments, denied downloads/file choosers/permissions, and HTTP(S)-only public navigation.
-- `allowEvaluation` exists only for the private confinement probe. No runtime lease, framed message, Flex tool, or MCP tool exposes evaluation.
-- The production probe verifies loopback denial, synthetic `.invalid` traversal, and forced WebRTC suppression through the resource's proxy.
-
-## Egress and artifacts
-
-- HTTP absolute-form, WebSocket Upgrade, and CONNECT use one fail-closed target resolver. Every DNS answer must be public unicast and the selected answer is dialed numerically.
-- Egress proxies carry immutable `projectId` and `browserResourceId`; credentials are private and one proxy exists per running resource.
-- Artifact identity is `(projectId, browserResourceId, artifactId)`. Paths use keyed project and resource digests, and quotas apply per resource, per project, and globally.
-- Artifact writes are private, temporary, synced, and atomically renamed. Reads use no-follow handles and verify size plus SHA-256. Human leases can read or delete artifacts only from their exact resource.
-
-## Adapter boundary
-
-- Framed messages contain no identity selectors. The parent binds project, resource, attachment authority/revision, actor, peer, role, source, qualified session, Flex scope, channel, and exact run out of band.
-- One qualified session can own multiple resource-specific framed channels. Capability revocation owns server-peer disconnect; peer-initiated release/close revokes only that channel's capability without recursively disconnecting itself.
-- Framed request counts and queued write bytes are bounded. Runtime shutdown has a bounded caller-visible cleanup deadline while retaining in-flight cleanup ownership for retry.
-- Each viewer has a bounded exact-identity frame map. Each incoming frame starts one bounded producer ACK whose outcome is shared by viewer records. Producer ACK promises have a separate hard bound; viewer lag and eviction cannot re-ACK or block Chrome. Producer failures fence the exact incarnation regardless of which participants subsequently joined it. A failure from an older incarnation cannot fence its replacement.
-- Late viewer acknowledgements and oldest-first eviction only retire the local map entry. A throwing listener revokes its own participant. Neither event routes through resource-wide producer failure handling.
-- A frame above `maxFrameBytes` advances the resource sequence watermark, is acknowledged once and dropped, and reports nonfatal `FRAME_TOO_LARGE` to viewers. During refresh it also fails the refresh boundary with `FRAME_TOO_LARGE`.
-- `screencast` (`quality` 0..100 default 70, `maxWidth`/`maxHeight` 1..4096 each with `maxWidth * maxHeight <= 8_294_400` and defaults 2560/1600, `everyNthFrame` 1..60 default 1, `firstFrameTimeoutMs` 1000..60000 default left to SmartPuppeteer) is validated in the constructor with `validateExactKeys` plus the integer validators and forwarded to `LiveBrowserSession` next to `maxOutstandingFrames`. The ceilings deliberately match `@push.rocks/smartpuppeteer` 2.6's `LiveBrowserSession` validation (`maxViewportPixelArea = 8294400`, `maxTimeoutMs = 60000`); a looser runtime bound would let `new BrowserRuntime()` succeed and every incarnation launch fail instead. Without `quality`/`maxWidth`/`maxHeight`, SmartPuppeteer's defaults (quality 80, unbounded size) produced multi-megabyte frames on device-pixel-ratio 2 viewers.
-- Refresh records track bounded producer ACK work independently of viewer windows. Producer failure cleanup is coalesced by exact session; affected operation completion waits for the fence and process cleanup. Closing an initiating subscription abandons its refresh without revoking other viewers.
-- Runtime state/error messages are bounded to 2,048 characters. Fatal producer errors revoke every current participant synchronously before captured error delivery; released participants receive no duplicate fatal notification.
-- Flex resolves only a capability token, and the provider's run must exactly match its trusted framed client. SmartAgent exposes exactly navigate, snapshot, screenshot, click, fill, and press.
-- MCP independent authentication returns the complete expected binding. The binding is retained in server-owned auth context and tool schemas expose no resource, session, revision, or authority selector.