@floegence/redevplugin-ui 0.5.1 → 0.6.5

package/dist/platform.d.ts

@@ -1,5 +1,5 @@
 import { type FetchLike } from "./http.js";
-import type { components, operations } from "./openapi.gen.js";
+import type { components } from "./openapi.gen.js";
 import { type PluginConfirmationHandler, type PluginSurfaceHost, type PluginSurfaceOpeningProgress, type PluginSurfaceReloadLimiter, type PluginSurfaceSlot, type PluginTrustedMethodResult, type ReDevPluginSurfaceTransport } from "./surface.js";
 import { type PluginSurfaceScope } from "./surface-scope.js";
 export type PluginPlatformClientOptions = {
@@ -46,7 +46,9 @@ export type PluginOpenSurfaceInSlotOptions = PluginRequestOptions & {
     onOpeningProgress?: (progress: PluginSurfaceOpeningProgress) => void;
     onError?: (error: import("./errors.js").PluginBridgeError) => void;
 };
-export type PluginSurfaceScopeRevokeResult = PlatformSchemas["SurfaceScopeRevokeResult"];
+export type PluginSessionScopeRevokeCounts = Readonly<PlatformSchemas["SessionScopeRevokeCounts"]>;
+export type PluginSessionScopeRevokeResult = Readonly<PlatformSchemas["SessionScopeRevokeCompleteResult"]>;
+export type PluginSessionScopeState = PluginSessionScopeRevokeResult["state"];
 export type PluginSurfaceBootstrapResult = PlatformSchemas["SurfaceBootstrap"];
 export type PluginRuntimeStartRequest = PlatformSchemas["StartRuntimeRequest"];
 export type PluginRuntimeTarget = NonNullable<PluginRuntimeStartRequest["target"]>;
@@ -72,15 +74,15 @@ export type PluginCapabilityContractPin = PlatformSchemas["HostCapabilityPinV1"]
 export type PluginPublicOperationBinding = PlatformSchemas["PublicOperationBinding"];
 export type PluginOperationRecord = PlatformSchemas["OperationRecord"];
 export type PluginOperationList = PlatformSchemas["PluginOperationList"];
-export type PluginOperationListOptions = NonNullable<operations["listPluginOperations"]["parameters"]["query"]>;
+export type PluginOperationListOptions = PlatformSchemas["ListOperationsQueryRequest"];
 export type PluginIntentRecord = PlatformSchemas["PluginIntentRecord"];
 export type PluginIntentList = PlatformSchemas["PluginIntentList"];
-export type PluginIntentListOptions = NonNullable<operations["listPluginIntents"]["parameters"]["query"]>;
+export type PluginIntentListOptions = PlatformSchemas["ListIntentsQueryRequest"];
 export type PluginIntentInvokeRequest = PlatformSchemas["InvokeIntentRequest"];
 export type PluginPermissionGrant = PlatformSchemas["PluginPermissionGrant"];
 export type PluginPermissionMutationResult = PlatformSchemas["PluginPermissionMutationResult"];
 export type PluginPermissionList = PlatformSchemas["PluginPermissionList"];
-export type PluginPermissionListOptions = NonNullable<operations["listPluginPermissionGrants"]["parameters"]["query"]>;
+export type PluginPermissionListOptions = PlatformSchemas["ListPermissionsQueryRequest"];
 export type PluginPermissionGrantRequest = PlatformSchemas["GrantPermissionRequest"];
 export type PluginPermissionRevokeRequest = PlatformSchemas["RevokePermissionRequest"];
 export type PluginSecurityPolicy = PlatformSchemas["PluginSecurityPolicy"];
@@ -94,7 +96,7 @@ export type PluginDataExportDeleteRequest = PlatformSchemas["DeleteDataExportReq
 export type PluginDataExportDeleteResult = PlatformSchemas["PluginDataExportDeleteResult"];
 export type PluginDataImportRequest = PlatformSchemas["ImportDataRequest"];
 export type PluginDataBinding = PlatformSchemas["PluginDataBinding"];
-export type PluginRetainedDataListOptions = NonNullable<operations["listPluginRetainedData"]["parameters"]["query"]>;
+export type PluginRetainedDataListOptions = PlatformSchemas["ListRetainedDataQueryRequest"];
 export type PluginRetainedDataList = PlatformSchemas["RetainedDataList"];
 export type PluginRetainedDataDeleteRequest = PlatformSchemas["DeleteRetainedDataRequest"];
 export type PluginRetainedDataBindRequest = PlatformSchemas["BindRetainedDataRequest"];
@@ -108,7 +110,7 @@ export type PluginDiagnosticEvent = PlatformSchemas["PluginDiagnosticEvent"];
 export type PluginDiagnosticEventList = PlatformSchemas["PluginDiagnosticEventList"];
 export type PluginDiagnosticDetails = PlatformSchemas["PluginDiagnosticDetails"];
 export type PluginDiagnosticMutationOutcome = PlatformSchemas["DiagnosticMutationOutcome"];
-export type PluginDiagnosticListOptions = NonNullable<operations["listPluginDiagnosticEvents"]["parameters"]["query"]>;
+export type PluginDiagnosticListOptions = PlatformSchemas["ListDiagnosticsQueryRequest"];
 export type PluginDiagnosticSeverity = NonNullable<PluginDiagnosticListOptions["severity"]>;
 export declare class PluginPlatformClient {
     #private;
@@ -123,7 +125,7 @@ export declare class PluginPlatformClient {
     disablePlugin(request: PluginDisableRequest, options?: PluginRequestOptions): Promise<PluginRecord>;
     uninstallPlugin(request: PluginUninstallRequest, options?: PluginRequestOptions): Promise<PluginRecord>;
     openSurfaceInSlot(slot: PluginSurfaceSlot, request: PluginOpenSurfaceRequest, options?: PluginOpenSurfaceInSlotOptions): Promise<PluginSurfaceHost>;
-    revokeSurfaceScope(options?: PluginRequestOptions): Promise<PluginSurfaceScopeRevokeResult>;
+    revokeSessionScope(options?: PluginRequestOptions): Promise<PluginSessionScopeRevokeResult>;
     startRuntime(request: PluginRuntimeStartRequest, options?: PluginRequestOptions): Promise<PluginRuntimeHealth>;
     stopRuntime(options?: PluginRequestOptions): Promise<PluginRuntimeStopResult>;
     refreshEnabledRuntimeState(options?: PluginRequestOptions): Promise<PluginRuntimeRefreshResult>;

package/dist/platform.js

@@ -1,7 +1,7 @@
-import { assertMutationDispatchable, defaultFetch, dispatchMutationRequest, readMutationPlatformResponse, readPlatformResponse, trimTrailingSlash, } from "./http.js";
+import { assertMutationDispatchable, defaultFetch, dispatchMutationRequest, dispatchQueryRequest, readMutationPlatformResponse, readPlatformResponse, trimTrailingSlash, } from "./http.js";
 import { PluginBridgeError, PluginMutationLifecycleError, PluginTransportError, pluginMutationOutcome, } from "./errors.js";
 import { createReDevPluginSurfaceTransport, openPluginSurfaceInSlot, } from "./surface.js";
-import { defaultPluginSurfaceScope, disposePluginSurfaceScope, } from "./surface-scope.js";
+import { defaultPluginSurfaceScope, disposePluginSurfaceScope, invalidatePluginSurfaceScope, } from "./surface-scope.js";
 function toPluginSurfaceHostBootstrap(value) {
     return {
         pluginId: value.plugin_id,
@@ -33,9 +33,9 @@ export class PluginPlatformClient {
         this.#surfaceTransport = options.surfaceTransport;
         this.#onMutationOutcomeUnknown = options.onMutationOutcomeUnknown;
     }
-    catalog(options = {}) { return this.#getJSON("/_redevplugin/api/plugins/catalog", options); }
-    features(options = {}) { return this.#getJSON("/_redevplugin/api/plugins/features", options); }
-    getCompatibility(options = {}) { return this.#getJSON("/_redevplugin/api/plugins/platform/compatibility", options); }
+    catalog(options = {}) { return this.#requestQuery("/_redevplugin/api/plugins/catalog/query", {}, options); }
+    features(options = {}) { return this.#requestQuery("/_redevplugin/api/plugins/features/query", {}, options); }
+    getCompatibility(options = {}) { return this.#requestQuery("/_redevplugin/api/plugins/platform/compatibility/query", {}, options); }
     installReleaseRef(request, options = {}) {
         return this.#requestMutation("POST", "/_redevplugin/api/plugins/install-release-ref", request, options);
     }
@@ -89,16 +89,20 @@ export class PluginPlatformClient {
             })),
         });
     }
-    async revokeSurfaceScope(options = {}) {
+    async revokeSessionScope(options = {}) {
         let result;
         try {
-            result = await this.#requestMutation("POST", "/_redevplugin/api/plugins/surfaces/revoke-scope", {}, options);
+            const raw = await this.#requestMutation("POST", "/_redevplugin/api/plugins/session/revoke-scope", {}, options);
+            if (!isPluginSessionScopeRevokeResult(raw)) {
+                throw new PluginTransportError("Plugin session scope revocation returned an invalid result", new PluginBridgeError("PLUGIN_CONTRACT_MISMATCH", "Invalid session scope revocation result"), "unknown");
+            }
+            result = raw;
         }
         catch (error) {
-            await this.#handleMutationFailure(error, undefined, "Plugin surface scope revocation and local teardown failed");
+            await this.#handleSessionRevokeFailure(error);
             throw error;
         }
-        await disposePluginSurfaceScope(this.#surfaceScope);
+        await invalidatePluginSurfaceScope(this.#surfaceScope);
         return result;
     }
     startRuntime(request, options = {}) {
@@ -110,41 +114,27 @@ export class PluginPlatformClient {
     refreshEnabledRuntimeState(options = {}) {
         return this.#requestMutation("POST", "/_redevplugin/api/plugins/runtime/refresh-enabled", {}, options);
     }
-    runtimeHealth(options = {}) { return this.#getJSON("/_redevplugin/api/plugins/runtime/health", options); }
+    runtimeHealth(options = {}) { return this.#requestQuery("/_redevplugin/api/plugins/runtime/health/query", {}, options); }
     getSettingsSchema(pluginInstanceId, scope, options = {}) {
-        return this.#getJSON(`/_redevplugin/api/plugins/${encodeURIComponent(pluginInstanceId)}/settings/schema?scope=${encodeURIComponent(scope)}`, options);
+        return this.#requestQuery(`/_redevplugin/api/plugins/${encodeURIComponent(pluginInstanceId)}/settings/schema/query`, { scope }, options);
     }
     getSettings(pluginInstanceId, scope, options = {}) {
-        return this.#getJSON(`/_redevplugin/api/plugins/${encodeURIComponent(pluginInstanceId)}/settings?scope=${encodeURIComponent(scope)}`, options);
+        return this.#requestQuery(`/_redevplugin/api/plugins/${encodeURIComponent(pluginInstanceId)}/settings/query`, { scope }, options);
     }
     patchSettings(pluginInstanceId, request, options = {}) {
         return this.#mutatePluginAt("PATCH", `/_redevplugin/api/plugins/${encodeURIComponent(pluginInstanceId)}/settings`, pluginInstanceId, request, options);
     }
     listOperations(options = {}, requestOptions = {}) {
-        const params = new URLSearchParams();
-        if (options.plugin_instance_id)
-            params.set("plugin_instance_id", options.plugin_instance_id);
-        if (options.cursor)
-            params.set("cursor", options.cursor);
-        if (options.limit !== undefined)
-            params.set("limit", String(options.limit));
-        const query = params.toString();
-        return this.#getJSON(`/_redevplugin/api/plugins/operations${query ? `?${query}` : ""}`, requestOptions);
+        return this.#requestQuery("/_redevplugin/api/plugins/operations/query", options, requestOptions);
     }
     getOperation(operationId, options = {}) {
-        return this.#getJSON(`/_redevplugin/api/plugins/operations/${encodeURIComponent(operationId)}`, options);
+        return this.#requestQuery(`/_redevplugin/api/plugins/operations/${encodeURIComponent(operationId)}/query`, {}, options);
     }
     cancelOperation(operationId, reason, options = {}) {
         return this.#requestMutation("POST", `/_redevplugin/api/plugins/operations/${encodeURIComponent(operationId)}/cancel`, reason ? { reason } : {}, options);
     }
     listIntents(options = {}, requestOptions = {}) {
-        const params = new URLSearchParams();
-        if (options.intent_id !== undefined)
-            params.set("intent_id", options.intent_id);
-        if (options.plugin_instance_id !== undefined)
-            params.set("plugin_instance_id", options.plugin_instance_id);
-        const query = params.toString();
-        return this.#getJSON(`/_redevplugin/api/plugins/intents${query ? `?${query}` : ""}`, requestOptions);
+        return this.#requestQuery("/_redevplugin/api/plugins/intents/query", options, requestOptions);
     }
     invokeIntent(request, options = {}) {
         return this.#requestMutation("POST", "/_redevplugin/api/plugins/intents/invoke", request, options);
@@ -159,11 +149,7 @@ export class PluginPlatformClient {
         return this.#mutatePluginAt("POST", "/_redevplugin/api/plugins/data/import", request.plugin_instance_id, request, options);
     }
     listRetainedData(options = {}, requestOptions = {}) {
-        const params = new URLSearchParams();
-        if (options.plugin_instance_id)
-            params.set("plugin_instance_id", options.plugin_instance_id);
-        const query = params.toString();
-        return this.#getJSON(`/_redevplugin/api/plugins/retained-data${query ? `?${query}` : ""}`, requestOptions);
+        return this.#requestQuery("/_redevplugin/api/plugins/retained-data/query", options, requestOptions);
     }
     deleteRetainedData(request, options = {}) {
         return this.#requestMutation("POST", "/_redevplugin/api/plugins/retained-data/delete", request, options);
@@ -175,13 +161,7 @@ export class PluginPlatformClient {
         return this.#requestMutation("POST", "/_redevplugin/api/plugins/retained-data/cleanup-expired", request, options);
     }
     listPermissions(options = {}, requestOptions = {}) {
-        const params = new URLSearchParams();
-        if (options.plugin_instance_id !== undefined)
-            params.set("plugin_instance_id", options.plugin_instance_id);
-        if (options.active_only !== undefined)
-            params.set("active_only", options.active_only ? "true" : "false");
-        const query = params.toString();
-        return this.#getJSON(`/_redevplugin/api/plugins/permissions${query ? `?${query}` : ""}`, requestOptions);
+        return this.#requestQuery("/_redevplugin/api/plugins/permissions/query", options, requestOptions);
     }
     grantPermission(request, options = {}) {
         return this.#mutatePlugin("/_redevplugin/api/plugins/permissions/grant", request, options);
@@ -190,10 +170,10 @@ export class PluginPlatformClient {
         return this.#mutatePlugin("/_redevplugin/api/plugins/permissions/revoke", request, options);
     }
     listSecurityPolicies(options = {}) {
-        return this.#getJSON("/_redevplugin/api/plugins/security-policies", options);
+        return this.#requestQuery("/_redevplugin/api/plugins/security-policies/query", {}, options);
     }
     getSecurityPolicy(pluginInstanceId, options = {}) {
-        return this.#getJSON(`/_redevplugin/api/plugins/security-policies/${encodeURIComponent(pluginInstanceId)}`, options);
+        return this.#requestQuery(`/_redevplugin/api/plugins/security-policies/${encodeURIComponent(pluginInstanceId)}/query`, {}, options);
     }
     putSecurityPolicy(pluginInstanceId, request, options = {}) {
         return this.#mutatePluginAt("PUT", `/_redevplugin/api/plugins/security-policies/${encodeURIComponent(pluginInstanceId)}`, pluginInstanceId, request, options);
@@ -211,10 +191,7 @@ export class PluginPlatformClient {
         return this.#requestMutation("POST", "/_redevplugin/api/plugins/secrets/delete", request, options);
     }
     listDiagnosticEvents(options = {}, requestOptions = {}) {
-        return this.#getJSON(`/_redevplugin/api/plugins/diagnostics${queryString(options)}`, requestOptions);
-    }
-    #getJSON(path, options) {
-        return this.#requestJSON("GET", path, options);
+        return this.#requestQuery("/_redevplugin/api/plugins/diagnostics/query", options, requestOptions);
     }
     #mutatePlugin(path, request, options) {
         return this.#mutatePluginAt("POST", path, request.plugin_instance_id, request, options);
@@ -232,7 +209,8 @@ export class PluginPlatformClient {
         return result;
     }
     async #handleMutationFailure(error, pluginInstanceId, message) {
-        if (pluginMutationOutcome(error) === "not_committed")
+        const outcome = pluginMutationOutcome(error);
+        if (outcome === "not_committed" || outcome === undefined)
             return;
         const lifecycleErrors = [];
         try {
@@ -241,28 +219,58 @@ export class PluginPlatformClient {
         catch (caught) {
             lifecycleErrors.push(caught);
         }
-        try {
-            this.#onMutationOutcomeUnknown?.(pluginInstanceId);
-        }
-        catch (caught) {
-            lifecycleErrors.push(caught);
+        if (outcome === "unknown") {
+            try {
+                this.#onMutationOutcomeUnknown?.(pluginInstanceId);
+            }
+            catch (caught) {
+                lifecycleErrors.push(caught);
+            }
         }
         if (lifecycleErrors.length > 0)
             throw new PluginMutationLifecycleError(message, error, lifecycleErrors);
     }
-    async #requestJSON(method, path, options) {
-        let response;
+    async #handleSessionRevokeFailure(error) {
+        const outcome = pluginMutationOutcome(error);
+        if (outcome === "not_committed")
+            return;
+        const lifecycleErrors = [];
+        if (outcome === "committed" || outcome === "unknown") {
+            try {
+                await invalidatePluginSurfaceScope(this.#surfaceScope);
+            }
+            catch (caught) {
+                lifecycleErrors.push(caught);
+            }
+        }
+        if (outcome === "unknown") {
+            try {
+                this.#onMutationOutcomeUnknown?.();
+            }
+            catch (caught) {
+                lifecycleErrors.push(caught);
+            }
+        }
+        if (lifecycleErrors.length > 0) {
+            throw new PluginMutationLifecycleError("Plugin session scope revocation and local invalidation failed", error, lifecycleErrors);
+        }
+    }
+    async #requestQuery(path, body, options) {
+        const operation = `POST ${path}`;
+        let encodedBody;
         try {
-            response = await this.#fetch(this.#apiBaseURL + path, {
-                method,
-                headers: { "Accept": "application/json" },
-                credentials: "same-origin",
-                signal: options.signal,
-            });
+            encodedBody = JSON.stringify(body);
         }
         catch (cause) {
-            throw new PluginTransportError(`Plugin platform request failed for ${method} ${path}`, cause);
+            throw new PluginTransportError(`Plugin platform query body serialization failed for ${operation}`, cause);
         }
+        const response = await dispatchQueryRequest(this.#fetch, this.#apiBaseURL + path, {
+            method: "POST",
+            headers: { "Accept": "application/json", "Content-Type": "application/json" },
+            body: encodedBody,
+            credentials: "same-origin",
+            signal: options.signal,
+        }, operation);
         return readPlatformResponse(response);
     }
     async #requestMutation(method, path, body, options) {
@@ -289,14 +297,38 @@ export class PluginPlatformClient {
         return readMutationPlatformResponse(response);
     }
 }
-function queryString(values) {
-    const params = new URLSearchParams();
-    for (const [key, value] of Object.entries(values)) {
-        if (value !== undefined)
-            params.set(key, String(value));
-    }
-    const query = params.toString();
-    return query ? `?${query}` : "";
+const sessionScopeCountKeys = [
+    "surfaces",
+    "asset_tickets",
+    "asset_sessions",
+    "plugin_gateway_tokens",
+    "confirmation_tokens",
+    "stream_tickets",
+    "handle_grants",
+    "confirmations",
+    "operations",
+    "streams",
+    "runtime_executions",
+    "active_network_requests",
+    "sockets",
+    "network_streams",
+    "storage_hostcalls",
+];
+function isPluginSessionScopeRevokeResult(value) {
+    if (!isExactRecord(value, ["state", "fenced", "complete", "counts"]) ||
+        value.state !== "complete" || value.fenced !== true || value.complete !== true)
+        return false;
+    const counts = value.counts;
+    if (!isExactRecord(counts, sessionScopeCountKeys))
+        return false;
+    return sessionScopeCountKeys.every((key) => Number.isSafeInteger(counts[key]) && Number(counts[key]) >= 0);
+}
+function isExactRecord(value, keys) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return false;
+    const actual = Object.keys(value).sort();
+    const expected = [...keys].sort();
+    return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
 }
 function surfaceTransportAPIBaseURL(value) {
     if (!value || value.startsWith("/"))

package/dist/surface-scope.d.ts

@@ -4,5 +4,6 @@ export declare class PluginSurfaceScope {
 }
 export declare function createPluginSurfaceScope(): PluginSurfaceScope;
 export declare const defaultPluginSurfaceScope: PluginSurfaceScope;
-export declare function registerPluginSurface(scope: PluginSurfaceScope, pluginInstanceId: string, dispose: () => Promise<void> | void): () => void;
+export declare function registerPluginSurface(scope: PluginSurfaceScope, pluginInstanceId: string, dispose: () => Promise<void> | void, invalidate: () => Promise<void> | void): () => void;
 export declare function disposePluginSurfaceScope(scope: PluginSurfaceScope, pluginInstanceId?: string): Promise<void>;
+export declare function invalidatePluginSurfaceScope(scope: PluginSurfaceScope): Promise<void>;

package/dist/surface-scope.js

@@ -1,4 +1,4 @@
-const registrations = new WeakMap();
+const scopes = new WeakMap();
 function canonicalPluginInstanceId(pluginInstanceId) {
     const canonical = typeof pluginInstanceId === "string" ? pluginInstanceId.trim() : "";
     if (!canonical)
@@ -7,7 +7,7 @@ function canonicalPluginInstanceId(pluginInstanceId) {
 }
 export class PluginSurfaceScope {
     constructor() {
-        registrations.set(this, new Map());
+        scopes.set(this, { invalidated: false, registrations: new Map() });
     }
     static create() {
         return new PluginSurfaceScope();
@@ -17,25 +17,34 @@ export function createPluginSurfaceScope() {
     return PluginSurfaceScope.create();
 }
 export const defaultPluginSurfaceScope = createPluginSurfaceScope();
-export function registerPluginSurface(scope, pluginInstanceId, dispose) {
-    const state = registrations.get(scope);
+export function registerPluginSurface(scope, pluginInstanceId, dispose, invalidate) {
+    const state = scopes.get(scope);
     if (!state)
         throw new TypeError("Plugin surface scope is invalid");
     const canonicalPluginId = canonicalPluginInstanceId(pluginInstanceId);
     const registration = Symbol(canonicalPluginId);
-    state.set(registration, { pluginInstanceId: canonicalPluginId, dispose });
-    return () => state.delete(registration);
+    if (state.invalidated) {
+        try {
+            void Promise.resolve(invalidate()).catch(() => undefined);
+        }
+        catch {
+            // A fenced session remains invalid even when a local observer fails.
+        }
+        return () => undefined;
+    }
+    state.registrations.set(registration, { pluginInstanceId: canonicalPluginId, dispose, invalidate });
+    return () => state.registrations.delete(registration);
 }
 export async function disposePluginSurfaceScope(scope, pluginInstanceId) {
-    const state = registrations.get(scope);
+    const state = scopes.get(scope);
     if (!state)
         throw new TypeError("Plugin surface scope is invalid");
     const canonicalPluginId = pluginInstanceId === undefined
         ? undefined
         : canonicalPluginInstanceId(pluginInstanceId);
-    const selected = [...state.entries()].filter(([, registration]) => canonicalPluginId === undefined || registration.pluginInstanceId === canonicalPluginId);
+    const selected = [...state.registrations.entries()].filter(([, registration]) => canonicalPluginId === undefined || registration.pluginInstanceId === canonicalPluginId);
     for (const [key] of selected)
-        state.delete(key);
+        state.registrations.delete(key);
     const results = await Promise.allSettled(selected.map(([, registration]) => Promise.resolve().then(() => registration.dispose())));
     const failures = results
         .filter((result) => result.status === "rejected")
@@ -45,3 +54,19 @@ export async function disposePluginSurfaceScope(scope, pluginInstanceId) {
     if (failures.length > 1)
         throw new AggregateError(failures, "Plugin surface scope teardown failed");
 }
+export async function invalidatePluginSurfaceScope(scope) {
+    const state = scopes.get(scope);
+    if (!state)
+        throw new TypeError("Plugin surface scope is invalid");
+    state.invalidated = true;
+    const selected = [...state.registrations.values()];
+    state.registrations.clear();
+    const results = await Promise.allSettled(selected.map((registration) => Promise.resolve().then(() => registration.invalidate())));
+    const failures = results
+        .filter((result) => result.status === "rejected")
+        .map((result) => result.reason);
+    if (failures.length === 1)
+        throw failures[0];
+    if (failures.length > 1)
+        throw new AggregateError(failures, "Plugin surface scope invalidation failed");
+}

package/dist/surface.js

@@ -2289,6 +2289,7 @@ class PluginSurfaceHostImplementation {
     #closePromise;
     #revokePromise;
     #unregisterSurfaceScope;
+    #onLocalInvalidation;
     #opened = false;
     #ready = false;
     #disposed = false;
@@ -2325,7 +2326,7 @@ class PluginSurfaceHostImplementation {
         this.#onOpeningProgress = options.onOpeningProgress;
         this.#onError = options.onError;
         hardenPluginSurfaceFrame(this.#iframe);
-        this.#unregisterSurfaceScope = registerPluginSurface(options.surfaceScope ?? defaultPluginSurfaceScope, this.bootstrap.pluginInstanceId, () => this.#disposeLocal());
+        this.#unregisterSurfaceScope = registerPluginSurface(options.surfaceScope ?? defaultPluginSurfaceScope, this.bootstrap.pluginInstanceId, () => this.#disposeLocal(), () => this.#invalidateLocal());
     }
     async open() {
         this.#assertActive();
@@ -2447,6 +2448,11 @@ class PluginSurfaceHostImplementation {
         this.#disposeLocal();
         return revoke;
     }
+    observeLocalInvalidation(observer) {
+        this.#onLocalInvalidation = observer;
+        if (this.#disposed)
+            observer();
+    }
     async #closeSurface() {
         const startedAt = performance.now();
         const quiesce = await this.#quiesceSurface();
@@ -2512,6 +2518,16 @@ class PluginSurfaceHostImplementation {
         }
         this.#iframe.srcdoc = "";
     }
+    #invalidateLocal() {
+        this.#disposeLocal();
+        this.#iframe.remove?.();
+        try {
+            this.#onLocalInvalidation?.();
+        }
+        catch {
+            // Slot state observers cannot weaken local session containment.
+        }
+    }
     async #handlePortMessage(event) {
         if (this.#disposed || !messageWithinLimit(event.data))
             return;
@@ -3201,6 +3217,7 @@ function createPluginSurfaceOpeningLease(request) {
     let unregister = () => undefined;
     let revokePromise;
     let removeAbortListener = () => undefined;
+    let invalidationObserver = () => undefined;
     const lease = {
         options: Promise.resolve(undefined),
         pluginInstanceId: request.pluginInstanceId,
@@ -3222,7 +3239,23 @@ function createPluginSurfaceOpeningLease(request) {
                 return Promise.resolve();
             return lease.revoke();
         },
+        invalidate() {
+            lease.cancelled = true;
+            if (lease.owner === "host" || lease.owner === "invalidated")
+                return;
+            lease.owner = "invalidated";
+            unregister();
+            removeAbortListener();
+            invalidationObserver();
+        },
+        observeInvalidation(observer) {
+            invalidationObserver = observer;
+            if (lease.owner === "invalidated")
+                observer();
+        },
         revoke() {
+            if (lease.owner === "invalidated")
+                return Promise.resolve();
             if (lease.owner === "host") {
                 throw new PluginBridgeError("PLUGIN_CONTRACT_MISMATCH", "Plugin surface ownership was already adopted");
             }
@@ -3236,12 +3269,17 @@ function createPluginSurfaceOpeningLease(request) {
             return revokePromise;
         },
     };
-    unregister = registerPluginSurface(request.surfaceScope, request.pluginInstanceId, () => lease.cancel());
-    try {
-        lease.options = Promise.resolve(request.open());
+    unregister = registerPluginSurface(request.surfaceScope, request.pluginInstanceId, () => lease.cancel(), () => lease.invalidate());
+    if (lease.owner === "invalidated") {
+        lease.options = Promise.reject(new PluginBridgeError("PLUGIN_BRIDGE_DISPOSED", "Plugin surface scope is invalidated"));
     }
-    catch (error) {
-        lease.options = Promise.reject(error);
+    else {
+        try {
+            lease.options = Promise.resolve(request.open());
+        }
+        catch (error) {
+            lease.options = Promise.reject(error);
+        }
     }
     void lease.options.catch(() => {
         if (lease.owner !== "opening")
@@ -3301,6 +3339,12 @@ export class PluginSurfaceSlot {
         const controller = new AbortController();
         this.#transitionController = controller;
         this.#setState("opening");
+        lease?.observeInvalidation(() => {
+            if (this.#transitionController !== controller)
+                return;
+            controller.abort();
+            this.#setState("empty");
+        });
         const transition = this.#tail.then(() => this.#openSurface(resolvedOptions, controller, lease), async (error) => {
             await this.#revokeOpening(lease);
             throw error;
@@ -3319,9 +3363,12 @@ export class PluginSurfaceSlot {
             resolvedOptions = await options;
         }
         catch (error) {
-            if (!this.#disposed && this.#transitionController === controller && !controller.signal.aborted) {
+            if (!this.#disposed && this.#transitionController === controller && !this.#openingCancelled(controller, lease)) {
                 this.#setState("error", toBridgeError(error, "PLUGIN_BRIDGE_HANDSHAKE_FAILED"));
             }
+            else {
+                this.#setCancelledState(controller);
+            }
             throw error;
         }
         if (lease && resolvedOptions.bootstrap.pluginInstanceId !== lease.pluginInstanceId) {
@@ -3360,6 +3407,17 @@ export class PluginSurfaceSlot {
             }
             throw error;
         }
+        host.observeLocalInvalidation(() => {
+            if (this.#active === host)
+                this.#active = undefined;
+            if (this.#opening === host)
+                this.#opening = undefined;
+            if (this.#transitionController === controller)
+                controller.abort();
+            host.element.remove();
+            if (!this.#disposed)
+                this.#setState("empty");
+        });
         this.#adoptOpening(lease);
         this.#opening = host;
         setSurfaceInteractive(host.element, false);
@@ -3788,7 +3846,8 @@ function isBridgeResponse(value) {
     if (value.ok !== false || typeof value.error_code !== "string" || !pluginBridgeErrorCodeSet.has(value.error_code) ||
         typeof value.error !== "string" || value.error.length > 4096 ||
         !Object.keys(value).every((key) => ["type", "id", "ok", "error_code", "error", "error_details", "mutation_outcome"].includes(key)) ||
-        (value.mutation_outcome !== undefined && value.mutation_outcome !== "not_committed" && value.mutation_outcome !== "unknown")) {
+        (value.mutation_outcome !== undefined && value.mutation_outcome !== "committed" &&
+            value.mutation_outcome !== "not_committed" && value.mutation_outcome !== "unknown")) {
         return false;
     }
     if (value.error_code === "PLUGIN_CAPABILITY_ERROR")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@floegence/redevplugin-ui",
-  "version": "0.5.1",
+  "version": "0.6.5",
   "license": "MIT",
   "type": "module",
   "repository": {
@@ -31,6 +31,9 @@
   "files": [
     "dist"
   ],
+  "dependencies": {
+    "@floegence/redevplugin-contracts": "0.6.5"
+  },
   "publishConfig": {
     "access": "public"
   },