@floegence/redevplugin-ui 0.7.27 → 1.0.0

package/dist/surface.js

@@ -11,26 +11,7 @@ export const pluginSurfaceContextSchemaVersion = "redevplugin.surface_context.v1
 const opaquePluginBridgeGlobalKey = "__redevpluginWorkerBridge";
 const maxPendingPluginBridgeRequests = 256;
 const maxPluginBridgeMessageBytes = opaqueSurfaceRenderLimits.max_message_bytes;
-const maxRetainedPluginStreamHandles = 128;
 const maxPluginJSONStructuralNodes = 32 * 1024;
-const streamCredentialInvalidatingErrorCodes = new Set([
-    "PLUGIN_BRIDGE_DISPOSED",
-    "PLUGIN_BRIDGE_HANDSHAKE_FAILED",
-    "PLUGIN_BRIDGE_HANDSHAKE_REQUIRED",
-    "PLUGIN_BRIDGE_TIMEOUT",
-    "PLUGIN_CONTRACT_MISMATCH",
-    "PLUGIN_GATEWAY_TOKEN_CHANNEL_MISMATCH",
-    "PLUGIN_GATEWAY_TOKEN_INVALID",
-    "PLUGIN_GATEWAY_TOKEN_REPLAYED",
-    "PLUGIN_GRANT_INVALID",
-    "PLUGIN_LEASE_INVALID",
-    "PLUGIN_LEASE_REPLAYED",
-    "PLUGIN_MANAGEMENT_REVISION_MISMATCH",
-    "PLUGIN_STREAM_CANCELLED",
-    "PLUGIN_STREAM_TICKET_INVALID",
-    "PLUGIN_TOKEN_EXPIRED",
-    "PLUGIN_TOKEN_REPLAY",
-]);
 const maxOpaqueSurfaceLazyAssets = 128;
 const maxOpaqueSurfaceLazyBytes = 32 * 1024 * 1024;
 const maxConcurrentAssetReads = 4;
@@ -62,8 +43,6 @@ export class PluginBridgeClient {
     #pendingRender;
     #renderLoop;
     #controlEditRevisions = new Map();
-    #pendingStreamDeliveries = new Map();
-    #streamReadTails = new Map();
     #onMessage = (event) => {
         void this.#handleMessage(event);
     };
@@ -111,81 +90,45 @@ export class PluginBridgeClient {
             request,
         }, { mutation, signal: options.signal });
     }
-    readStream(streamHandle, options = {}) {
+    executionEvents(executionID, afterCursor, options = {}) {
         this.#assertActive();
-        if (!validOpaqueHandle(streamHandle, "stream")) {
-            throw new PluginBridgeError("PLUGIN_INVALID_REQUEST", "Plugin stream handle is invalid");
+        if (!validOpaqueHandle(executionID, "execution") || !Number.isSafeInteger(afterCursor) || afterCursor < 0) {
+            throw new PluginBridgeError("PLUGIN_INVALID_REQUEST", "Plugin execution event cursor is invalid");
         }
-        const previous = this.#streamReadTails.get(streamHandle);
-        const read = (previous ? previous.catch(() => undefined) : Promise.resolve()).then(() => {
-            this.#assertActive();
-            if (options.signal?.aborted)
-                throw streamReadAbortedError();
-            return this.#readStream(streamHandle, options.signal);
-        });
-        this.#streamReadTails.set(streamHandle, read);
-        void read.finally(() => {
-            if (this.#streamReadTails.get(streamHandle) === read)
-                this.#streamReadTails.delete(streamHandle);
-        }).catch(() => undefined);
-        return abortableStreamRead(read, options.signal);
-    }
-    async #readStream(streamHandle, signal) {
-        const pending = this.#pendingStreamDeliveries.get(streamHandle);
-        if (pending) {
-            await this.#acknowledgeStream(streamHandle, pending.deliveryID, signal);
-            this.#pendingStreamDeliveries.delete(streamHandle);
-            return pending.result;
-        }
-        const id = this.#requestID("stream");
-        const privateResult = await this.#request(id, {
-            type: "redevplugin.bridge.stream.read",
-            id,
-            stream_handle: streamHandle,
-        }, { cancellationKind: "stream", signal });
-        const { delivery_id: deliveryID, ...result } = privateResult;
-        if (!deliveryID)
-            return result;
-        this.#pendingStreamDeliveries.set(streamHandle, { deliveryID, result });
-        await this.#acknowledgeStream(streamHandle, deliveryID, signal);
-        this.#pendingStreamDeliveries.delete(streamHandle);
-        return result;
-    }
-    async #acknowledgeStream(streamHandle, deliveryID, signal) {
-        const id = this.#requestID("stream_ack");
-        await this.#request(id, {
-            type: "redevplugin.bridge.stream.ack",
+        const id = this.#requestID("execution");
+        return this.#request(id, {
+            type: "redevplugin.bridge.execution.events",
             id,
-            stream_handle: streamHandle,
-            delivery_id: deliveryID,
-        }, { cancellationKind: "stream", signal });
+            execution_id: executionID,
+            after_cursor: afterCursor,
+        }, { signal: options.signal });
     }
-    cancelOperation(operationID, reason, options = {}) {
+    cancelExecution(executionID, reason, options = {}) {
         this.#assertActive();
-        if (!validOpaqueHandle(operationID, "operation") || (reason !== undefined && (typeof reason !== "string" || reason.length > 256))) {
-            throw new PluginBridgeError("PLUGIN_INVALID_REQUEST", "Plugin operation cancellation is invalid");
+        if (!validOpaqueHandle(executionID, "execution") || (reason !== undefined && (typeof reason !== "string" || reason.length > 256))) {
+            throw new PluginBridgeError("PLUGIN_INVALID_REQUEST", "Plugin execution cancellation is invalid");
         }
-        const id = this.#requestID("operation");
+        const id = this.#requestID("execution");
         return this.#request(id, removeUndefined({
-            type: "redevplugin.bridge.operation.cancel",
+            type: "redevplugin.bridge.execution.cancel",
             id,
-            operation_id: operationID,
+            execution_id: executionID,
             reason,
         }), { mutation: true, signal: options.signal });
     }
-    operationSnapshot(operationID, options = {}) {
+    executionSnapshot(executionID, options = {}) {
         this.#assertActive();
-        if (!validOpaqueHandle(operationID, "operation")) {
-            throw new PluginBridgeError("PLUGIN_INVALID_REQUEST", "Plugin operation handle is invalid");
+        if (!validOpaqueHandle(executionID, "execution")) {
+            throw new PluginBridgeError("PLUGIN_INVALID_REQUEST", "Plugin execution handle is invalid");
         }
-        const id = this.#requestID("operation");
+        const id = this.#requestID("execution");
         return this.#request(id, {
-            type: "redevplugin.bridge.operation.snapshot",
+            type: "redevplugin.bridge.execution.query",
             id,
-            operation_id: operationID,
+            execution_id: executionID,
         }, { signal: options.signal }).then((snapshot) => {
-            if (!isPluginOperationSnapshot(snapshot) || snapshot.operation_id !== operationID) {
-                throw new PluginBridgeError("PLUGIN_CONTRACT_MISMATCH", "Plugin operation snapshot is invalid");
+            if (!isPluginExecutionSnapshot(snapshot) || snapshot.execution_id !== executionID) {
+                throw new PluginBridgeError("PLUGIN_CONTRACT_MISMATCH", "Plugin execution snapshot is invalid");
             }
             return snapshot;
         });
@@ -313,7 +256,6 @@ export class PluginBridgeClient {
             pending.reject(new PluginBridgeError("PLUGIN_BRIDGE_DISPOSED", `Plugin bridge request ${id} was disposed`));
         }
         this.#pending.clear();
-        this.#pendingStreamDeliveries.clear();
         this.#actionHandlers.clear();
         this.#canvasInputHandlers.clear();
         this.#lifecycleHandlers.clear();
@@ -655,18 +597,19 @@ export function isPluginRiskPlan(plan) {
         (plan.effect == null || isPluginRiskEffect(plan.effect)) &&
         (plan.details == null || isRecord(plan.details));
 }
-export function decodePluginStreamText(event) {
-    if (!event.data)
+export function decodePluginEventText(event) {
+    const data = event.payload?.data;
+    if (typeof data !== "string" || data === "")
         return "";
     if (typeof TextDecoder === "function" && typeof atob === "function") {
-        const binary = atob(event.data);
+        const binary = atob(data);
         const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
         return new TextDecoder().decode(bytes);
     }
     const bufferLike = globalThis.Buffer;
     if (bufferLike)
-        return bufferLike.from(event.data, "base64").toString("utf8");
-    throw new PluginBridgeError("PLUGIN_STREAM_FAILED", "No base64 decoder is available for plugin stream data");
+        return bufferLike.from(data, "base64").toString("utf8");
+    throw new PluginBridgeError("PLUGIN_STREAM_FAILED", "No base64 decoder is available for plugin execution event data");
 }
 export async function trustedParentBridgeHandshakeTranscriptSHA256(handshake, bridgeChannelID) {
     const subtle = globalThis.crypto?.subtle;
@@ -771,8 +714,8 @@ export function createOpaquePluginBootstrapHTML(options = {}) {
         throw new Error("scriptNonce must contain 8-128 URL-safe characters");
     }
     const uiProtocolVersion = options.uiProtocolVersion ?? pluginUIProtocolVersion;
-    if (uiProtocolVersion !== "plugin-ui-v5" && uiProtocolVersion !== "plugin-ui-v6" && uiProtocolVersion !== "plugin-ui-v7") {
-        throw new Error("uiProtocolVersion must be plugin-ui-v5, plugin-ui-v6, or plugin-ui-v7");
+    if (uiProtocolVersion !== pluginUIProtocolVersion) {
+        throw new Error(`uiProtocolVersion must be ${pluginUIProtocolVersion}`);
     }
     const csp = [
         "default-src 'none'",
@@ -863,7 +806,6 @@ export function createOpaquePluginBootstrapHTML(options = {}) {
   const validIdentifier = (value) => typeof value === "string" && /^[A-Za-z0-9._:-]{1,128}$/.test(value);
   const validResourceIdentifier = (value) => typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(value);
   const validOpaqueHandle = (value, prefix) => typeof value === "string" && value.startsWith(prefix + "_") && /^[A-Za-z0-9_-]{8,160}$/.test(value);
-  const validDeliveryID = (value) => typeof value === "string" && /^delivery_[A-Za-z0-9_-]{8,128}$/.test(value);
   const validDigest = (value) => typeof value === "string" && /^sha256:[a-f0-9]{64}$/.test(value);
   const validPath = (value) => typeof value === "string" && value.length > 0 && value.length <= 512 && !value.startsWith("/") && !value.includes("\\\\") && !value.split("/").some((part) => !part || part === "." || part === "..");
   const validAttribute = (tag, name, value) => {
@@ -928,14 +870,14 @@ export function createOpaquePluginBootstrapHTML(options = {}) {
   let workerHeartbeatTimeout;
   let pendingQuiesceID;
   const pendingWorkerRequests = new Set();
-  const requestSequence = { rpc: 0, stream: 0, stream_ack: 0, render: 0, operation: 0, canvas: 0, asset: 0 };
-  let operationSnapshotSurfaceTokens = 8;
-  let operationSnapshotSurfaceRefillAt = performance.now();
-  const operationSnapshotStateIdleMS = 120000;
-  let operationSnapshotNextPruneAt = performance.now() + 30000;
-  const maxOperationSnapshotStates = 1024;
-  const operationSnapshotStates = new Map();
-  const operationSnapshotRequests = new Map();
+  const requestSequence = { rpc: 0, execution: 0, render: 0, canvas: 0, asset: 0 };
+  let executionQuerySurfaceTokens = 8;
+  let executionQuerySurfaceRefillAt = performance.now();
+  const executionQueryStateIdleMS = 120000;
+  let executionQueryNextPruneAt = performance.now() + 30000;
+  const maxExecutionQueryStates = 1024;
+  const executionQueryStates = new Map();
+  const executionQueryRequests = new Map();
   let renderWindowStartedAt = 0;
   let renderCount = 0;
   let uiRevision = 0;
@@ -1045,8 +987,8 @@ export function createOpaquePluginBootstrapHTML(options = {}) {
     for (const url of blobURLs) URL.revokeObjectURL(url);
     blobURLs.clear();
     pendingWorkerRequests.clear();
-    operationSnapshotStates.clear();
-    operationSnapshotRequests.clear();
+    executionQueryStates.clear();
+    executionQueryRequests.clear();
     pendingAssets.clear();
     queuedAssets.length = 0;
     activeAssetReads = 0;
@@ -2041,7 +1983,7 @@ export function createOpaquePluginBootstrapHTML(options = {}) {
   const validCall = (value) => exactKeys(value, ["type", "request"]) && value.type === "redevplugin.bridge.call" && isRecord(value.request) && Object.keys(value.request).every((key) => ["id", "method", "params"].includes(key)) && typeof value.request.id === "string" && value.request.id.length <= 128 && typeof value.request.method === "string" && /^[A-Za-z0-9._:-]{1,256}$/.test(value.request.method) && (value.request.params === undefined || isRecord(value.request.params));
   const requestID = (value, expectedKind) => {
     if (typeof value !== "string") return undefined;
-    const match = /^(rpc|stream|stream_ack|render|operation|canvas|asset)_([1-9][0-9]{0,15})$/.exec(value);
+    const match = /^(rpc|execution|render|canvas|asset)_([1-9][0-9]{0,15})$/.exec(value);
     if (!match || match[1] !== expectedKind) return undefined;
     const sequence = Number(match[2]);
     return Number.isSafeInteger(sequence) ? { kind: match[1], sequence } : undefined;
@@ -2054,10 +1996,10 @@ export function createOpaquePluginBootstrapHTML(options = {}) {
     return true;
   };
   const completeWorkerRequest = (id) => pendingWorkerRequests.delete(id);
-  const completeOperationSnapshotRequest = (id) => {
-    const operationID = operationSnapshotRequests.get(id);
-    operationSnapshotRequests.delete(id);
-    const state = operationSnapshotStates.get(operationID);
+  const completeExecutionQueryRequest = (id) => {
+    const executionID = executionQueryRequests.get(id);
+    executionQueryRequests.delete(id);
+    const state = executionQueryStates.get(executionID);
     if (state) { state.inFlight = false; state.lastSeen = performance.now(); }
     completeWorkerRequest(id);
   };
@@ -2065,24 +2007,24 @@ export function createOpaquePluginBootstrapHTML(options = {}) {
     tokens: Math.min(burst, tokens + Math.max(0, now - refillAt) * rate / 1000),
     refillAt: Math.max(refillAt, now),
   });
-  const operationSnapshotRateLimit = (operationID, requestID) => {
+  const executionQueryRateLimit = (executionID, requestID) => {
     const now = performance.now();
-    const surface = refillSnapshotTokens(operationSnapshotSurfaceTokens, operationSnapshotSurfaceRefillAt, 8, 8, now);
-    operationSnapshotSurfaceTokens = surface.tokens;
-    operationSnapshotSurfaceRefillAt = surface.refillAt;
-    if (operationSnapshotSurfaceTokens < 1) return Math.max(500, Math.min(10000, Math.ceil((1 - operationSnapshotSurfaceTokens) / 8 * 1000)));
-    operationSnapshotSurfaceTokens -= 1;
-    let existing = operationSnapshotStates.get(operationID);
+    const surface = refillSnapshotTokens(executionQuerySurfaceTokens, executionQuerySurfaceRefillAt, 8, 8, now);
+    executionQuerySurfaceTokens = surface.tokens;
+    executionQuerySurfaceRefillAt = surface.refillAt;
+    if (executionQuerySurfaceTokens < 1) return Math.max(500, Math.min(10000, Math.ceil((1 - executionQuerySurfaceTokens) / 8 * 1000)));
+    executionQuerySurfaceTokens -= 1;
+    let existing = executionQueryStates.get(executionID);
     if (!existing) {
-      if (now >= operationSnapshotNextPruneAt) {
-        for (const [retainedOperationID, state] of operationSnapshotStates) {
-          if (!state.inFlight && now - state.lastSeen >= operationSnapshotStateIdleMS) operationSnapshotStates.delete(retainedOperationID);
+      if (now >= executionQueryNextPruneAt) {
+        for (const [retainedExecutionID, state] of executionQueryStates) {
+          if (!state.inFlight && now - state.lastSeen >= executionQueryStateIdleMS) executionQueryStates.delete(retainedExecutionID);
         }
-        operationSnapshotNextPruneAt = now + 30000;
+        executionQueryNextPruneAt = now + 30000;
       }
-      if (operationSnapshotStates.size >= maxOperationSnapshotStates) return 10000;
+      if (executionQueryStates.size >= maxExecutionQueryStates) return 10000;
       existing = { tokens: 2, refillAt: now, lastSeen: now, inFlight: false };
-      operationSnapshotStates.set(operationID, existing);
+      executionQueryStates.set(executionID, existing);
     }
     const operation = refillSnapshotTokens(existing.tokens, existing.refillAt, 2, 2, now);
     existing.tokens = operation.tokens;
@@ -2093,7 +2035,7 @@ export function createOpaquePluginBootstrapHTML(options = {}) {
     if (retryAfterMS > 0) return Math.max(500, Math.min(10000, retryAfterMS));
     existing.tokens -= 1;
     existing.inFlight = true;
-    operationSnapshotRequests.set(requestID, operationID);
+    executionQueryRequests.set(requestID, executionID);
     return 0;
   };
   const renderRateAllowed = () => {
@@ -2309,36 +2251,30 @@ export function createOpaquePluginBootstrapHTML(options = {}) {
       sendParent(message);
       return;
     }
-    if (exactKeys(message, ["type", "id", "stream_handle"]) && message.type === "redevplugin.bridge.stream.read" && typeof message.id === "string" && validOpaqueHandle(message.stream_handle, "stream")) {
-      if (!acceptWorkerRequest(message.id, "stream")) return rejectWorkerRequest(message.id, "duplicate, replayed, or excessive plugin request");
-      sendParent(message);
-      return;
-    }
-    if (exactKeys(message, ["type", "id", "stream_handle", "delivery_id"]) && message.type === "redevplugin.bridge.stream.ack" &&
-        requestID(message.id, "stream_ack") && validOpaqueHandle(message.stream_handle, "stream") && validDeliveryID(message.delivery_id)) {
-      if (!acceptWorkerRequest(message.id, "stream_ack")) return rejectWorkerRequest(message.id, "duplicate, replayed, or excessive plugin request");
-      sendParent(message);
-      return;
-    }
-    if (isRecord(message) && Object.keys(message).every((key) => ["type", "id", "operation_id", "reason"].includes(key)) &&
-        message.type === "redevplugin.bridge.operation.cancel" && typeof message.id === "string" &&
-        validOpaqueHandle(message.operation_id, "operation") && (message.reason === undefined || (typeof message.reason === "string" && message.reason.length <= 256))) {
-      if (!acceptWorkerRequest(message.id, "operation")) return rejectWorkerRequest(message.id, "duplicate, replayed, or excessive plugin request");
+    if (isRecord(message) && Object.keys(message).every((key) => ["type", "id", "execution_id", "reason"].includes(key)) &&
+        message.type === "redevplugin.bridge.execution.cancel" && typeof message.id === "string" &&
+        validOpaqueHandle(message.execution_id, "execution") && (message.reason === undefined || (typeof message.reason === "string" && message.reason.length <= 256))) {
+      if (!acceptWorkerRequest(message.id, "execution")) return rejectWorkerRequest(message.id, "duplicate, replayed, or excessive plugin request");
       sendParent(message);
       return;
     }
-    if (exactKeys(message, ["type", "id", "operation_id"]) && message.type === "redevplugin.bridge.operation.snapshot" &&
-        typeof message.id === "string" && validOpaqueHandle(message.operation_id, "operation")) {
-      if (protocolVersion !== "plugin-ui-v6" && protocolVersion !== "plugin-ui-v7") return rejectWorkerRequest(message.id, "plugin operation observation requires plugin-ui-v6 or plugin-ui-v7");
-      if (!acceptWorkerRequest(message.id, "operation")) return rejectWorkerRequest(message.id, "duplicate, replayed, or excessive plugin request");
-      const retryAfterMS = operationSnapshotRateLimit(message.operation_id, message.id);
+    if (exactKeys(message, ["type", "id", "execution_id"]) && message.type === "redevplugin.bridge.execution.query" &&
+        typeof message.id === "string" && validOpaqueHandle(message.execution_id, "execution")) {
+      if (!acceptWorkerRequest(message.id, "execution")) return rejectWorkerRequest(message.id, "duplicate, replayed, or excessive plugin request");
+      const retryAfterMS = executionQueryRateLimit(message.execution_id, message.id);
       if (retryAfterMS > 0) {
         completeWorkerRequest(message.id);
-        return sendWorker({ type: "redevplugin.bridge.response", id: message.id, ok: false, error_code: "PLUGIN_OPERATION_RATE_LIMITED", error: "plugin operation snapshot rate limited", error_details: { retry_after_ms: retryAfterMS } });
+        return sendWorker({ type: "redevplugin.bridge.response", id: message.id, ok: false, error_code: "PLUGIN_EXECUTION_BLOCKED", error: "plugin execution query rate limited" });
       }
       sendParent(message);
       return;
     }
+    if (exactKeys(message, ["type", "id", "execution_id", "after_cursor"]) && message.type === "redevplugin.bridge.execution.events" &&
+        typeof message.id === "string" && validOpaqueHandle(message.execution_id, "execution") && Number.isSafeInteger(message.after_cursor) && message.after_cursor >= 0) {
+      if (!acceptWorkerRequest(message.id, "execution")) return rejectWorkerRequest(message.id, "duplicate, replayed, or excessive plugin request");
+      sendParent(message);
+      return;
+    }
     if (exactKeys(message, ["type", "id", "canvas_id"]) && message.type === "redevplugin.ui.canvas.open" && typeof message.id === "string" && validResourceIdentifier(message.canvas_id)) {
       if (!acceptWorkerRequest(message.id, "canvas")) return rejectWorkerRequest(message.id, "duplicate, replayed, or excessive plugin request");
       openCanvas(message.id, message.canvas_id);
@@ -2392,7 +2328,7 @@ export function createOpaquePluginBootstrapHTML(options = {}) {
         completeWorkerRequest(message.id);
         return;
       }
-      if (operationSnapshotRequests.has(message.id)) completeOperationSnapshotRequest(message.id);
+      if (executionQueryRequests.has(message.id)) completeExecutionQueryRequest(message.id);
       else completeWorkerRequest(message.id);
       sendParent(message);
       return;
@@ -2401,13 +2337,12 @@ export function createOpaquePluginBootstrapHTML(options = {}) {
   const onParentMessage = async (event) => {
     const message = event.data;
     if (!initialized) {
-      const initKeys = ["type", "frame_generation_id", "surface_handle", "document"];
-      if (protocolVersion === "plugin-ui-v7") initKeys.push("context");
-      if (!isRecord(message) || !Object.keys(message).every((key) => initKeys.includes(key)) || !initKeys.slice(0, 4).every((key) => Object.prototype.hasOwnProperty.call(message, key)) || message.type !== "redevplugin.surface.initialize" || message.frame_generation_id !== frameGenerationID || !validOpaqueHandle(message.surface_handle, "surface") || !validDocument(message.document) || (protocolVersion === "plugin-ui-v7" && message.context !== undefined && !validSurfaceContext(message.context))) return fail("invalid private initialize message");
+      const initKeys = ["type", "frame_generation_id", "surface_handle", "document", "context"];
+      if (!isRecord(message) || !Object.keys(message).every((key) => initKeys.includes(key)) || !initKeys.slice(0, 4).every((key) => Object.prototype.hasOwnProperty.call(message, key)) || message.type !== "redevplugin.surface.initialize" || message.frame_generation_id !== frameGenerationID || !validOpaqueHandle(message.surface_handle, "surface") || !validDocument(message.document) || (message.context !== undefined && !validSurfaceContext(message.context))) return fail("invalid private initialize message");
       initialized = true;
       surfaceHandle = message.surface_handle;
       currentDocument = message.document;
-      currentContext = protocolVersion === "plugin-ui-v7" ? message.context : undefined;
+      currentContext = message.context;
       try { applyStaticDocument(currentDocument); if (currentContext) applySurfaceContext(currentContext); startWorker(currentDocument); }
       catch (error) { return fail(error); }
       requestAnimationFrame(() => requestAnimationFrame(() => {
@@ -2416,7 +2351,7 @@ export function createOpaquePluginBootstrapHTML(options = {}) {
       }));
       return;
     }
-    if (protocolVersion === "plugin-ui-v7" && isRecord(message) && exactKeys(message, ["type", "frame_generation_id", "surface_handle", "context"]) && message.type === "redevplugin.surface.context" && message.frame_generation_id === frameGenerationID && message.surface_handle === surfaceHandle && validSurfaceContext(message.context)) {
+    if (isRecord(message) && exactKeys(message, ["type", "frame_generation_id", "surface_handle", "context"]) && message.type === "redevplugin.surface.context" && message.frame_generation_id === frameGenerationID && message.surface_handle === surfaceHandle && validSurfaceContext(message.context)) {
       if (currentContext && message.context.revision <= currentContext.revision) return;
       currentContext = message.context;
       applySurfaceContext(currentContext);
@@ -2424,7 +2359,7 @@ export function createOpaquePluginBootstrapHTML(options = {}) {
       return;
     }
     if (message && message.type === "redevplugin.bridge.response" && typeof message.id === "string" && pendingWorkerRequests.has(message.id) && withinLimit(message)) {
-	  if (operationSnapshotRequests.has(message.id)) completeOperationSnapshotRequest(message.id);
+	  if (executionQueryRequests.has(message.id)) completeExecutionQueryRequest(message.id);
 	  else completeWorkerRequest(message.id);
       sendWorker(message);
       return;
@@ -2502,7 +2437,6 @@ class PluginSurfaceHostImplementation {
     #document;
     #surfaceContext;
     #assets = new Map();
-    #streamCredentials = new Map();
     #pendingRequestControllers = new Map();
     #activeTransportRequests = 0;
     #activeAssetReads = 0;
@@ -2639,7 +2573,7 @@ class PluginSurfaceHostImplementation {
             frame_generation_id: this.frameGenerationId,
             surface_handle: this.surfaceHandle,
             document: preparation.document,
-            context: this.bootstrap.uiProtocolVersion === "plugin-ui-v7" ? this.#surfaceContext : undefined,
+            context: this.#surfaceContext,
         }));
         this.#rendererInitialized = true;
         await Promise.all([signals.firstPaint.promise, signals.workerReady.promise]);
@@ -2658,9 +2592,6 @@ class PluginSurfaceHostImplementation {
     }
     updateContext(context) {
         this.#assertActive();
-        if (this.bootstrap.uiProtocolVersion !== "plugin-ui-v7") {
-            throw new PluginBridgeError("PLUGIN_UI_PROTOCOL_UNSUPPORTED", "Plugin surface context requires plugin-ui-v7");
-        }
         const normalized = normalizePluginSurfaceContext(context);
         if (this.#surfaceContext && normalized.revision <= this.#surfaceContext.revision) {
             throw new PluginBridgeError("PLUGIN_INVALID_REQUEST", "Plugin surface context revision must increase monotonically");
@@ -2757,7 +2688,6 @@ class PluginSurfaceHostImplementation {
         this.#assetSessionID = undefined;
         this.#document = undefined;
         this.#assets.clear();
-        this.#streamCredentials.clear();
         if (this.#port) {
             try {
                 this.#port.postMessage({ type: "redevplugin.bridge.lifecycle", event: { type: "dispose" } });
@@ -2824,20 +2754,16 @@ class PluginSurfaceHostImplementation {
                 await this.#handleCall(data.request);
                 return;
             }
-            if (isStreamReadMessage(data)) {
-                await this.#handleStreamRead(data.id, data.stream_handle);
-                return;
-            }
-            if (isStreamAcknowledgeMessage(data)) {
-                await this.#handleStreamAcknowledge(data.id, data.stream_handle, data.delivery_id);
+            if (isExecutionCancelMessage(data)) {
+                await this.#handleExecutionCancel(data);
                 return;
             }
-            if (isOperationCancelMessage(data)) {
-                await this.#handleOperationCancel(data);
+            if (isExecutionQueryMessage(data)) {
+                await this.#handleExecutionQuery(data);
                 return;
             }
-            if (isOperationSnapshotMessage(data)) {
-                await this.#handleOperationSnapshot(data);
+            if (isExecutionEventsMessage(data)) {
+                await this.#handleExecutionEvents(data);
                 return;
             }
             if (isAssetReadMessage(data)) {
@@ -2939,152 +2865,57 @@ class PluginSurfaceHostImplementation {
             this.#postError(request.id, bridgeError.errorCode, bridgeError.message, bridgeError.details, bridgeError.mutationOutcome);
         }
     }
-    async #handleStreamRead(id, streamHandle) {
-        const credential = this.#streamCredentials.get(streamHandle);
-        if (!credential || credential.completed || credential.reading || credential.acknowledging) {
-            this.#postError(id, "PLUGIN_STREAM_TICKET_INVALID", "Plugin stream handle is invalid, completed, or busy");
-            return;
-        }
-        if (credential.expiresAtMs <= Date.now()) {
-            this.#postError(id, "PLUGIN_STREAM_TICKET_INVALID", "Plugin stream handle is expired");
-            return;
-        }
-        if (credential.pending) {
-            this.#postResponse(id, credential.pending.response);
-            return;
-        }
-        credential.reading = true;
-        const controller = this.#registerPendingRequest(id);
-        try {
-            const readPath = `/_redevplugin/api/plugins/surfaces/${encodeURIComponent(this.bootstrap.surfaceInstanceId)}/streams/read`;
-            const readBody = () => ({ stream_id: credential.streamID, stream_ticket: credential.streamTicket, read_id: credential.readID });
-            let result;
-            try {
-                result = await this.#postJSON(readPath, readBody, controller.signal);
-            }
-            catch (error) {
-                if (!retryableStreamReadTransportFailure(error) || controller.signal.aborted || this.#disposed)
-                    throw error;
-                result = await this.#postJSON(readPath, readBody, controller.signal);
-            }
-            if (!isStreamReadResult(result, credential.streamID, credential.readID, credential.lastSequence)) {
-                throw new PluginBridgeError("PLUGIN_CONTRACT_MISMATCH", "Plugin stream endpoint returned an invalid response");
-            }
-            const lastSequence = result.events.length > 0 ? result.events[result.events.length - 1].sequence : credential.lastSequence;
-            const events = result.events.map(publicPluginStreamEvent);
-            const response = result.done
-                ? { delivery_id: result.delivery_id, events, done: true, terminal_status: result.terminal_status, retry_after_ms: 0 }
-                : { delivery_id: result.delivery_id, events, done: false, retry_after_ms: events.length === 0 ? 25 : 0 };
-            if (result.delivery_id) {
-                credential.pending = {
-                    deliveryID: result.delivery_id,
-                    lastSequence,
-                    done: result.done,
-                    response,
-                };
-            }
-            credential.reading = false;
-            if (!controller.signal.aborted && !this.#disposed)
-                this.#postResponse(id, response);
-        }
-        catch (error) {
-            const bridgeError = toBridgeError(error, "PLUGIN_RUNTIME_UNAVAILABLE");
-            if (streamReadFailureInvalidatesCredential(bridgeError)) {
-                this.#streamCredentials.delete(streamHandle);
-            }
-            else {
-                credential.reading = false;
-            }
-            if (controller.signal.aborted || this.#disposed)
-                return;
-            this.#postError(id, bridgeError.errorCode, bridgeError.message);
-        }
-        finally {
-            this.#pendingRequestControllers.delete(id);
-        }
-    }
-    async #handleStreamAcknowledge(id, streamHandle, deliveryID) {
-        const credential = this.#streamCredentials.get(streamHandle);
-        if (!credential || credential.reading || credential.acknowledging) {
-            this.#postError(id, "PLUGIN_STREAM_DELIVERY_INVALID", "Plugin stream delivery is invalid or busy", undefined, "not_committed");
-            return;
-        }
-        if (credential.lastAcknowledgedDeliveryID === deliveryID) {
-            this.#postResponse(id, undefined);
-            return;
-        }
-        if (!credential.pending || credential.pending.deliveryID !== deliveryID) {
-            this.#postError(id, "PLUGIN_STREAM_DELIVERY_INVALID", "Plugin stream delivery does not match the pending batch", undefined, "not_committed");
-            return;
-        }
-        credential.acknowledging = true;
-        const controller = this.#registerPendingRequest(id);
+    async #handleExecutionCancel(message) {
+        const controller = this.#registerPendingRequest(message.id);
         try {
-            const result = await this.#postMutationJSON(`/_redevplugin/api/plugins/surfaces/${encodeURIComponent(this.bootstrap.surfaceInstanceId)}/streams/ack`, () => ({
-                stream_id: credential.streamID,
-                stream_ticket: credential.streamTicket,
-                delivery_id: deliveryID,
-            }), controller.signal);
-            if (!hasExactKeys(result, ["acknowledged"]) || result.acknowledged !== true) {
-                throw new PluginBridgeError("PLUGIN_CONTRACT_MISMATCH", "Plugin stream acknowledgement endpoint returned an invalid response", undefined, undefined, "unknown");
-            }
-            const pending = credential.pending;
-            credential.lastAcknowledgedDeliveryID = deliveryID;
-            credential.lastSequence = pending.lastSequence;
-            credential.pending = undefined;
-            credential.readID = randomOpaqueHandle("read");
-            credential.completed = pending.done;
-            credential.acknowledging = false;
+            await this.#postMutationJSON(`/_redevplugin/api/plugins/executions/${encodeURIComponent(message.execution_id)}/cancel`, { reason: message.reason }, controller.signal);
             if (!controller.signal.aborted && !this.#disposed)
-                this.#postResponse(id, undefined);
+                this.#postResponse(message.id, undefined);
         }
         catch (error) {
-            credential.acknowledging = false;
             if (controller.signal.aborted || this.#disposed)
                 return;
-            const bridgeError = toBridgeError(error, "PLUGIN_STREAM_DELIVERY_INVALID");
-            this.#postError(id, bridgeError.errorCode, bridgeError.message, bridgeError.details, bridgeError.mutationOutcome);
+            const bridgeError = toBridgeError(error, "PLUGIN_EXECUTION_BLOCKED");
+            this.#postError(message.id, bridgeError.errorCode, bridgeError.message, bridgeError.details, bridgeError.mutationOutcome);
         }
         finally {
-            this.#pendingRequestControllers.delete(id);
+            this.#pendingRequestControllers.delete(message.id);
         }
     }
-    async #handleOperationCancel(message) {
+    async #handleExecutionQuery(message) {
         const controller = this.#registerPendingRequest(message.id);
         try {
-            await this.#postMutationJSON(`/_redevplugin/api/plugins/surfaces/${encodeURIComponent(this.bootstrap.surfaceInstanceId)}/operations/cancel`, { operation_id: message.operation_id, bridge_channel_id: this.bridgeChannelId, reason: message.reason }, controller.signal);
-            this.#releaseOperationStreams(message.operation_id);
+            const snapshot = await this.#postJSON(`/_redevplugin/api/plugins/executions/${encodeURIComponent(message.execution_id)}/query`, {}, controller.signal);
+            if (!isPluginExecutionSnapshot(snapshot) || snapshot.execution_id !== message.execution_id) {
+                throw new PluginBridgeError("PLUGIN_CONTRACT_MISMATCH", "Plugin execution snapshot endpoint returned an invalid response");
+            }
             if (!controller.signal.aborted && !this.#disposed)
-                this.#postResponse(message.id, undefined);
+                this.#postResponse(message.id, snapshot);
         }
         catch (error) {
             if (controller.signal.aborted || this.#disposed)
                 return;
-            const bridgeError = toBridgeError(error, "PLUGIN_OPERATION_BLOCKED");
+            const bridgeError = toBridgeError(error, "PLUGIN_EXECUTION_NOT_FOUND");
             this.#postError(message.id, bridgeError.errorCode, bridgeError.message, bridgeError.details, bridgeError.mutationOutcome);
         }
         finally {
             this.#pendingRequestControllers.delete(message.id);
         }
     }
-    async #handleOperationSnapshot(message) {
-        if (this.bootstrap.uiProtocolVersion !== "plugin-ui-v6" && this.bootstrap.uiProtocolVersion !== "plugin-ui-v7") {
-            this.#postError(message.id, "PLUGIN_UI_PROTOCOL_UNSUPPORTED", "Plugin operation observation requires plugin-ui-v6 or plugin-ui-v7");
-            return;
-        }
+    async #handleExecutionEvents(message) {
         const controller = this.#registerPendingRequest(message.id);
         try {
-            const snapshot = await this.#postJSON(`/_redevplugin/api/plugins/surfaces/${encodeURIComponent(this.bootstrap.surfaceInstanceId)}/operations/query`, { operation_id: message.operation_id, bridge_channel_id: this.bridgeChannelId }, controller.signal);
-            if (!isPluginOperationSnapshot(snapshot) || snapshot.operation_id !== message.operation_id) {
-                throw new PluginBridgeError("PLUGIN_CONTRACT_MISMATCH", "Plugin operation snapshot endpoint returned an invalid response");
+            const result = await this.#postJSON(`/_redevplugin/api/plugins/executions/${encodeURIComponent(message.execution_id)}/events/query`, { after_cursor: message.after_cursor }, controller.signal);
+            if (!isPluginExecutionEventList(result, message.execution_id, message.after_cursor)) {
+                throw new PluginBridgeError("PLUGIN_CONTRACT_MISMATCH", "Plugin execution event endpoint returned an invalid response");
             }
             if (!controller.signal.aborted && !this.#disposed)
-                this.#postResponse(message.id, snapshot);
+                this.#postResponse(message.id, result);
         }
         catch (error) {
             if (controller.signal.aborted || this.#disposed)
                 return;
-            const bridgeError = toBridgeError(error, "PLUGIN_OPERATION_NOT_FOUND");
+            const bridgeError = toBridgeError(error, "PLUGIN_EXECUTION_NOT_FOUND");
             this.#postError(message.id, bridgeError.errorCode, bridgeError.message, bridgeError.details, bridgeError.mutationOutcome);
         }
         finally {
@@ -3133,52 +2964,13 @@ class PluginSurfaceHostImplementation {
         return controller;
     }
     #publicMethodResult(result) {
-        const publicResult = {
+        return removeUndefined({
             data: result.data,
-            operation_id: result.operation_id,
+            execution_id: result.execution_id,
             confirmation_required: result.confirmation_required,
             confirmation_token_id: result.confirmation_token_id,
             request_hash: result.request_hash,
-        };
-        if (result.stream_id || result.stream_ticket || result.stream_ticket_id || result.stream_expires_at) {
-            if (!result.operation_id || !result.stream_id || !result.stream_ticket || !result.stream_ticket_id || !result.stream_expires_at) {
-                throw new PluginBridgeError("PLUGIN_CONTRACT_MISMATCH", "Plugin RPC returned incomplete stream credentials");
-            }
-            const expiresAtMs = Date.parse(result.stream_expires_at);
-            if (!Number.isFinite(expiresAtMs) || expiresAtMs <= Date.now()) {
-                throw new PluginBridgeError("PLUGIN_STREAM_TICKET_INVALID", "Plugin RPC returned an expired stream ticket");
-            }
-            this.#pruneExpiredStreamCredentials();
-            if (this.#streamCredentials.size >= maxRetainedPluginStreamHandles) {
-                throw new PluginBridgeError("PLUGIN_JSON_LIMIT_EXCEEDED", "Plugin surface retained too many unread stream handles");
-            }
-            const handle = randomOpaqueHandle("stream");
-            this.#streamCredentials.set(handle, {
-                streamID: result.stream_id,
-                operationID: result.operation_id,
-                streamTicket: result.stream_ticket,
-                expiresAtMs,
-                lastSequence: 0,
-                readID: randomOpaqueHandle("read"),
-                reading: false,
-                acknowledging: false,
-                completed: false,
-            });
-            publicResult.stream_handle = handle;
-        }
-        return removeUndefined(publicResult);
-    }
-    #pruneExpiredStreamCredentials(now = Date.now()) {
-        for (const [handle, credential] of this.#streamCredentials) {
-            if (credential.expiresAtMs <= now)
-                this.#streamCredentials.delete(handle);
-        }
-    }
-    #releaseOperationStreams(operationID) {
-        for (const [handle, credential] of this.#streamCredentials) {
-            if (credential.operationID === operationID)
-                this.#streamCredentials.delete(handle);
-        }
+        });
     }
     #callRPC(request, confirmationID, signal) {
         return this.#postMutationJSON("/_redevplugin/api/plugins/rpc", () => this.#rpcBody(request, confirmationID), signal);
@@ -4066,7 +3858,7 @@ function validateHostBootstrap(bootstrap) {
             throw new PluginBridgeError("PLUGIN_CONTRACT_MISMATCH", "Plugin surface bootstrap is incomplete");
         }
     }
-    if (bootstrap.uiProtocolVersion !== "plugin-ui-v5" && bootstrap.uiProtocolVersion !== "plugin-ui-v6" && bootstrap.uiProtocolVersion !== "plugin-ui-v7") {
+    if (bootstrap.uiProtocolVersion !== pluginUIProtocolVersion) {
         throw new PluginBridgeError("PLUGIN_CONTRACT_MISMATCH", "Plugin surface UI protocol is unsupported");
     }
     if (!Number.isSafeInteger(bootstrap.managementRevision) || bootstrap.managementRevision < 1 ||
@@ -4214,42 +4006,32 @@ function isBridgeCallMessage(value) {
         validMethod(value.request.method) &&
         validRPCParams(value.request.params);
 }
-function isStreamReadMessage(value) {
-    return hasExactKeys(value, ["type", "id", "stream_handle"]) &&
-        value.type === "redevplugin.bridge.stream.read" &&
-        validBridgeRequestID(value.id, "stream") &&
-        validOpaqueHandle(value.stream_handle, "stream");
-}
-function isStreamAcknowledgeMessage(value) {
-    return hasExactKeys(value, ["type", "id", "stream_handle", "delivery_id"]) &&
-        value.type === "redevplugin.bridge.stream.ack" &&
-        validBridgeRequestID(value.id, "stream_ack") &&
-        validOpaqueHandle(value.stream_handle, "stream") &&
-        validDeliveryID(value.delivery_id);
-}
-function isOperationCancelMessage(value) {
-    return hasAllowedKeys(value, ["type", "id", "operation_id", "reason"]) &&
-        value.type === "redevplugin.bridge.operation.cancel" &&
-        validBridgeRequestID(value.id, "operation") &&
-        validOpaqueHandle(value.operation_id, "operation") &&
+function isExecutionCancelMessage(value) {
+    return hasAllowedKeys(value, ["type", "id", "execution_id", "reason"]) &&
+        value.type === "redevplugin.bridge.execution.cancel" &&
+        validBridgeRequestID(value.id, "execution") &&
+        validOpaqueHandle(value.execution_id, "execution") &&
         (value.reason === undefined || (typeof value.reason === "string" && value.reason.length <= 256));
 }
-function isOperationSnapshotMessage(value) {
-    return hasExactKeys(value, ["type", "id", "operation_id"]) &&
-        value.type === "redevplugin.bridge.operation.snapshot" &&
-        validBridgeRequestID(value.id, "operation") &&
-        validOpaqueHandle(value.operation_id, "operation");
+function isExecutionQueryMessage(value) {
+    return hasExactKeys(value, ["type", "id", "execution_id"]) && value.type === "redevplugin.bridge.execution.query" &&
+        validBridgeRequestID(value.id, "execution") && validOpaqueHandle(value.execution_id, "execution");
+}
+function isExecutionEventsMessage(value) {
+    return hasExactKeys(value, ["type", "id", "execution_id", "after_cursor"]) && value.type === "redevplugin.bridge.execution.events" &&
+        validBridgeRequestID(value.id, "execution") && validOpaqueHandle(value.execution_id, "execution") &&
+        Number.isSafeInteger(value.after_cursor) && Number(value.after_cursor) >= 0;
 }
-function isPluginOperationSnapshot(value) {
-    if (!isRecord(value) || !validOpaqueHandle(value.operation_id, "operation") || typeof value.cancelable !== "boolean" ||
-        !Number.isInteger(value.retry_after_ms) || Number(value.retry_after_ms) < 500 || Number(value.retry_after_ms) > 10000 ||
-        !validDateTime(value.created_at) || !validDateTime(value.updated_at))
+function isPluginExecutionSnapshot(value) {
+    if (!isRecord(value) || !validOpaqueHandle(value.execution_id, "execution") || typeof value.plugin_instance_id !== "string" ||
+        (value.kind !== "operation" && value.kind !== "subscription") || typeof value.cancelable !== "boolean" ||
+        !Number.isSafeInteger(value.cursor) || Number(value.cursor) < 0 || !validDateTime(value.created_at) || !validDateTime(value.updated_at))
         return false;
-    const common = ["operation_id", "status", "cancelable", "created_at", "updated_at", "retry_after_ms"];
+    const common = ["execution_id", "plugin_instance_id", "kind", "status", "cursor", "cancelable", "created_at", "updated_at"];
     const withProgress = (keys) => hasAllowedKeys(value, [...keys, "progress"]) && (value.progress === undefined || validOperationProgress(value.progress));
     if (value.status === "running" || value.status === "cancel_requested")
         return withProgress(common);
-    if (["completed", "canceled", "orphaned_after_disable", "orphaned_after_uninstall"].includes(String(value.status))) {
+    if (["completed", "canceled", "orphaned"].includes(String(value.status))) {
         return withProgress([...common, "terminal_at"]) && validDateTime(value.terminal_at);
     }
     return value.status === "failed" && withProgress([...common, "terminal_at", "failure_code"]) &&
@@ -4268,6 +4050,22 @@ function validOperationProgress(value) {
 function validDateTime(value) {
     return typeof value === "string" && value.length > 0 && Number.isFinite(Date.parse(value));
 }
+function isPluginExecutionEventList(value, executionID, afterCursor) {
+    if (!hasExactKeys(value, ["execution_id", "events", "cursor"]) || value.execution_id !== executionID ||
+        !Array.isArray(value.events) || !Number.isSafeInteger(value.cursor) || Number(value.cursor) < afterCursor)
+        return false;
+    let cursor = afterCursor;
+    for (const event of value.events) {
+        if (!isRecord(event) || !hasAllowedKeys(event, ["execution_id", "sequence", "kind", "payload", "error"]) ||
+            event.execution_id !== executionID || !Number.isSafeInteger(event.sequence) || Number(event.sequence) <= cursor ||
+            !["progress", "data", "diagnostic", "terminal"].includes(String(event.kind)) ||
+            (event.payload !== undefined && !isRecord(event.payload)) ||
+            (event.error !== undefined && (!hasExactKeys(event.error, ["code", "message"]) || typeof event.error.code !== "string" || typeof event.error.message !== "string")))
+            return false;
+        cursor = Number(event.sequence);
+    }
+    return Number(value.cursor) === cursor;
+}
 function isBridgeCancelMessage(value) {
     return hasExactKeys(value, ["type", "id"]) &&
         value.type === "redevplugin.bridge.cancel" &&
@@ -4539,48 +4337,6 @@ function isGatewayTokenResult(value) {
         typeof value.asset_session_id === "string" && value.asset_session_id.length > 0 &&
         typeof value.issued_at === "string" && typeof value.expires_at === "string";
 }
-function isStreamReadResult(value, expectedStreamID, expectedReadID, previousSequence) {
-    if (!isRecord(value) || typeof value.done !== "boolean" || !Array.isArray(value.events))
-        return false;
-    const hasDelivery = value.events.length > 0 || value.done;
-    const expectedKeys = value.done
-        ? ["delivery_id", "done", "events", "read_id", "terminal_status"]
-        : hasDelivery
-            ? ["delivery_id", "done", "events", "read_id"]
-            : ["done", "events", "read_id"];
-    if (!hasExactKeys(value, expectedKeys))
-        return false;
-    if (value.read_id !== expectedReadID || (hasDelivery && !validDeliveryID(value.delivery_id)))
-        return false;
-    if (value.done) {
-        if (!validPluginStreamTerminalStatus(value.terminal_status))
-            return false;
-    }
-    let terminal = false;
-    for (const event of value.events) {
-        if (!isStreamEvent(event) || event.stream_id !== expectedStreamID || event.sequence <= previousSequence || terminal)
-            return false;
-        previousSequence = event.sequence;
-        terminal = event.kind === "end" || event.kind === "error";
-    }
-    return true;
-}
-function isStreamEvent(value) {
-    return hasAllowedKeys(value, ["stream_id", "sequence", "kind", "data", "error", "at"]) &&
-        typeof value.stream_id === "string" &&
-        Number.isSafeInteger(value.sequence) && Number(value.sequence) > 0 &&
-        typeof value.kind === "string" && value.kind.length > 0 &&
-        (value.data == null || typeof value.data === "string") &&
-        (value.error == null || typeof value.error === "string") &&
-        typeof value.at === "string";
-}
-function publicPluginStreamEvent(event) {
-    return removeUndefined({ sequence: event.sequence, kind: event.kind, data: event.data, error: event.error, at: event.at });
-}
-function validPluginStreamTerminalStatus(value) {
-    return value === "closed" || value === "canceled" || value === "failed" ||
-        value === "orphaned_after_disable" || value === "orphaned_after_uninstall";
-}
 function validRPCParams(value) {
     if (value === undefined)
         return true;
@@ -4596,7 +4352,7 @@ const pluginMethodPattern = new RegExp("^[-A-Za-z0-9._:]{1,256}$");
 const pluginActionPattern = new RegExp("^[-A-Za-z0-9._:]{1,128}$");
 const pluginUIIdentifierPattern = new RegExp("^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$");
 const opaqueHandlePattern = new RegExp("^[-A-Za-z0-9_]{8,160}$");
-const bridgeRequestIDPattern = /^(rpc|stream|stream_ack|render|operation|canvas|asset)_([1-9][0-9]{0,15})$/;
+const bridgeRequestIDPattern = /^(rpc|execution|render|canvas|asset)_([1-9][0-9]{0,15})$/;
 function validBridgeRequestID(value, expectedKind) {
     if (typeof value !== "string")
         return false;
@@ -4617,9 +4373,6 @@ function validUIIdentifier(value) {
 function validOpaqueHandle(value, prefix) {
     return typeof value === "string" && value.startsWith(`${prefix}_`) && opaqueHandlePattern.test(value);
 }
-function validDeliveryID(value) {
-    return typeof value === "string" && /^delivery_[A-Za-z0-9_-]{8,128}$/.test(value);
-}
 function validSHA256(value) {
     return typeof value === "string" && /^sha256:[a-f0-9]{64}$/.test(value);
 }
@@ -4720,25 +4473,6 @@ function requestCancelledError(options, posted) {
         return streamReadAbortedError();
     return new PluginBridgeError("PLUGIN_BRIDGE_CANCELLED", "Plugin bridge request was cancelled", undefined, undefined, mutationOutcome(options, posted));
 }
-function abortableStreamRead(read, signal) {
-    if (!signal)
-        return read;
-    if (signal.aborted)
-        return Promise.reject(streamReadAbortedError());
-    return new Promise((resolve, reject) => {
-        let settled = false;
-        const finish = (callback, value) => {
-            if (settled)
-                return;
-            settled = true;
-            signal.removeEventListener("abort", onAbort);
-            callback(value);
-        };
-        const onAbort = () => finish(reject, streamReadAbortedError());
-        signal.addEventListener("abort", onAbort, { once: true });
-        read.then((value) => finish(resolve, value), (error) => finish(reject, error));
-    });
-}
 function abortableConfirmationDecision(decision, signal) {
     if (signal.aborted) {
         return Promise.reject(new PluginBridgeError("PLUGIN_BRIDGE_DISPOSED", "Plugin confirmation was aborted"));
@@ -4877,12 +4611,3 @@ function toBridgeError(error, defaultCode) {
         return new PluginBridgeError(defaultCode, error.message);
     return new PluginBridgeError(defaultCode, String(error));
 }
-function streamReadFailureInvalidatesCredential(error) {
-    if (!(error instanceof PluginBridgeError))
-        return true;
-    return streamCredentialInvalidatingErrorCodes.has(error.errorCode);
-}
-function retryableStreamReadTransportFailure(error) {
-    return error instanceof PluginTransportError ||
-        (error instanceof PluginBridgeError && error.errorCode === "PLUGIN_BRIDGE_TIMEOUT");
-}