@floegence/redevplugin-ui 0.7.26 → 1.0.0

package/dist/capability-client.d.ts

@@ -1,5 +1,5 @@
 import { PluginBridgeError } from "./errors.js";
-import type { PluginBridgeClient, PluginBridgeRequestOptions, PluginJSONObject, PluginStreamEvent as PluginRawStreamEvent, PluginStreamTerminalStatus, PluginOperationSnapshot } from "./surface.js";
+import type { PluginBridgeClient, PluginBridgeRequestOptions, PluginJSONObject, PluginExecutionEvent as PluginRawExecutionEvent, PluginExecutionSnapshot } from "./surface.js";
 export type PluginCapabilitySchema = Readonly<Record<string, unknown>>;
 export type PluginCapabilityEffect = "read" | "write" | "execute" | "delete" | "admin";
 type PluginCapabilityMethodContract = {
@@ -24,52 +24,50 @@ export type PluginCapabilityBusinessErrorSpec = {
     detail_schema_sha256: string;
     schema: PluginCapabilitySchema | null;
 };
-export type PluginOperationWaitOptions = {
+export type PluginExecutionWaitOptions = {
     signal?: AbortSignal;
     timeoutMs?: number;
     pollIntervalMs?: number;
 };
-export type PluginOperationTerminalStatus = {
-    [Status in Extract<PluginOperationSnapshot["status"], "completed" | "failed" | "canceled" | "orphaned_after_disable" | "orphaned_after_uninstall">]: {
+export type PluginExecutionTerminalStatus = {
+    [Status in Extract<PluginExecutionSnapshot["status"], "completed" | "failed" | "canceled" | "orphaned">]: {
         status: Status;
-        snapshot: Extract<PluginOperationSnapshot, {
+        snapshot: Extract<PluginExecutionSnapshot, {
             status: Status;
         }>;
     };
-}[Extract<PluginOperationSnapshot["status"], "completed" | "failed" | "canceled" | "orphaned_after_disable" | "orphaned_after_uninstall">];
-type PluginOperationObservation = {
-    snapshot(options?: PluginBridgeRequestOptions): Promise<PluginOperationSnapshot>;
-    wait(options?: PluginOperationWaitOptions): Promise<PluginOperationTerminalStatus>;
+}[Extract<PluginExecutionSnapshot["status"], "completed" | "failed" | "canceled" | "orphaned">];
+type PluginExecutionObservation = {
+    snapshot(options?: PluginBridgeRequestOptions): Promise<PluginExecutionSnapshot>;
+    wait(options?: PluginExecutionWaitOptions): Promise<PluginExecutionTerminalStatus>;
 };
-export type PluginOperation<T, Cancelable extends boolean = true> = PluginOperationObservation & {
+export type PluginExecution<T, Cancelable extends boolean = true> = PluginExecutionObservation & {
     data: T;
-    operation_id: string;
+    execution_id: string;
 } & (Cancelable extends true ? {
     cancel(reason?: string, options?: PluginBridgeRequestOptions): Promise<void>;
 } : Record<never, never>);
-export type PluginCapabilityStreamEvent<Event> = Omit<PluginRawStreamEvent, "data" | "error"> & {
+export type PluginCapabilityStreamEvent<Event> = Omit<PluginRawExecutionEvent, "payload" | "error"> & {
     data: Event;
 };
 export type PluginCapabilityStreamReadResult<Event> = {
     events: PluginCapabilityStreamEvent<Event>[];
     done: false;
-    retry_after_ms: number;
+    cursor: number;
 } | {
     events: PluginCapabilityStreamEvent<Event>[];
     done: true;
-    terminal_status: PluginStreamTerminalStatus;
-    retry_after_ms: 0;
+    cursor: number;
 };
-export type PluginStream<Initial, Event> = PluginOperationObservation & {
+export type PluginStream<Initial, Event> = PluginExecutionObservation & {
     data: Initial;
-    operation_id: string;
-    stream_handle: string;
+    execution_id: string;
     read(options?: PluginBridgeRequestOptions): Promise<PluginCapabilityStreamReadResult<Event>>;
     cancel(reason?: string, options?: PluginBridgeRequestOptions): Promise<void>;
     [Symbol.asyncIterator](): AsyncIterableIterator<PluginCapabilityStreamEvent<Event>>;
 };
 export declare function callCapabilitySync<Request extends object, Response>(bridge: PluginBridgeClient, contract: PluginCapabilitySyncContract, request: Request, options?: PluginBridgeRequestOptions): Promise<Response>;
-export declare function callCapabilityOperation<Request extends object, Response, Cancelable extends boolean = true>(bridge: PluginBridgeClient, contract: PluginCapabilityOperationContract<Cancelable>, request: Request, options?: PluginBridgeRequestOptions): Promise<PluginOperation<Response, Cancelable>>;
+export declare function callCapabilityOperation<Request extends object, Response, Cancelable extends boolean = true>(bridge: PluginBridgeClient, contract: PluginCapabilityOperationContract<Cancelable>, request: Request, options?: PluginBridgeRequestOptions): Promise<PluginExecution<Response, Cancelable>>;
 export declare function callCapabilityStream<Request extends object, Response, Event>(bridge: PluginBridgeClient, contract: PluginCapabilityStreamContract, request: Request, options?: PluginBridgeRequestOptions): Promise<PluginStream<Response, Event>>;
 export declare function isCapabilityBusinessError(error: unknown, capabilityID: string, capabilityVersion: string, detailSchemas: Readonly<Record<string, PluginCapabilityBusinessErrorSpec>>): error is PluginBridgeError & {
     readonly details: PluginJSONObject;

package/dist/capability-client.js

@@ -1,6 +1,6 @@
 import { PluginBridgeError } from "./errors.js";
 import { callPluginBridgeCapability } from "./bridge-capability.js";
-import { decodePluginStreamText } from "./surface.js";
+import { decodePluginEventText } from "./surface.js";
 export async function callCapabilitySync(bridge, contract, request, options = {}) {
     const params = validateRequest(request, contract.requestSchema);
     const result = parseSyncResult(contract.method, await callPluginBridgeCapability(bridge, contract.method, params, contract.effect, options));
@@ -15,16 +15,16 @@ export async function callCapabilityOperation(bridge, contract, request, options
     }
     catch (error) {
         if (contract.cancelable)
-            await cancelAfterResponseMismatch(bridge, result.operation_id, error);
+            await cancelAfterResponseMismatch(bridge, result.execution_id, error);
         throw error;
     }
-    const observation = operationObservation(bridge, result.operation_id);
+    const observation = executionObservation(bridge, result.execution_id);
     return Object.freeze({
         data: data,
-        operation_id: result.operation_id,
+        execution_id: result.execution_id,
         ...observation,
         ...(contract.cancelable ? {
-            cancel: (reason, cancelOptions) => bridge.cancelOperation(result.operation_id, reason, cancelOptions),
+            cancel: (reason, cancelOptions) => bridge.cancelExecution(result.execution_id, reason, cancelOptions),
         } : {}),
     });
 }
@@ -36,12 +36,14 @@ export async function callCapabilityStream(bridge, contract, request, options =
         data = validateResponse(contract.method, result.data, contract.responseSchema);
     }
     catch (error) {
-        await cancelAfterResponseMismatch(bridge, result.operation_id, error);
+        return cancelAfterResponseMismatch(bridge, result.execution_id, error);
     }
     let settled = false;
+    let cursor = 0;
     const read = async (options = {}) => {
         try {
-            const batch = decodeCapabilityStreamBatch(contract.method, await bridge.readStream(result.stream_handle, options), contract.eventTypeName, contract.eventSchema);
+            const batch = decodeCapabilityStreamBatch(contract.method, await bridge.executionEvents(result.execution_id, cursor, options), contract.eventTypeName, contract.eventSchema);
+            cursor = batch.cursor;
             if (batch.done)
                 settled = true;
             return batch;
@@ -50,21 +52,24 @@ export async function callCapabilityStream(bridge, contract, request, options =
             if (options.signal?.aborted && error instanceof PluginBridgeError && error.errorCode === "PLUGIN_STREAM_CANCELLED") {
                 throw error;
             }
+            if (error instanceof PluginBridgeError && error.errorCode === "PLUGIN_STREAM_FAILED") {
+                settled = true;
+                throw error;
+            }
             settled = true;
-            return cancelAfterStreamMismatch(bridge, result.operation_id, error);
+            return cancelAfterStreamMismatch(bridge, result.execution_id, error);
         }
     };
     const cancel = async (reason, cancelOptions = {}) => {
         if (settled)
             return;
-        await bridge.cancelOperation(result.operation_id, reason, cancelOptions);
+        await bridge.cancelExecution(result.execution_id, reason, cancelOptions);
         settled = true;
     };
-    const observation = operationObservation(bridge, result.operation_id);
+    const observation = executionObservation(bridge, result.execution_id);
     return Object.freeze({
         data: data,
-        operation_id: result.operation_id,
-        stream_handle: result.stream_handle,
+        execution_id: result.execution_id,
         ...observation,
         read,
         cancel,
@@ -74,14 +79,10 @@ export async function callCapabilityStream(bridge, contract, request, options =
                     const batch = await read();
                     for (const event of batch.events)
                         yield event;
-                    if (batch.done) {
-                        if (batch.terminal_status === "closed")
-                            return;
-                        throw pluginStreamTerminalError(batch.terminal_status);
-                    }
-                    if (batch.events.length === 0 && batch.retry_after_ms > 0) {
-                        await new Promise((resolve) => setTimeout(resolve, batch.retry_after_ms));
-                    }
+                    if (batch.done)
+                        return;
+                    if (batch.events.length === 0)
+                        await new Promise((resolve) => setTimeout(resolve, 250));
                 }
             }
             finally {
@@ -91,8 +92,8 @@ export async function callCapabilityStream(bridge, contract, request, options =
         },
     });
 }
-function operationObservation(bridge, operationID) {
-    const snapshot = (options = {}) => bridge.operationSnapshot(operationID, options);
+function executionObservation(bridge, executionID) {
+    const snapshot = (options = {}) => bridge.executionSnapshot(executionID, options);
     const wait = async (options = {}) => {
         const timeoutMs = options.timeoutMs ?? 120_000;
         if (!Number.isFinite(timeoutMs) || timeoutMs < 1_000 || timeoutMs > 600_000) {
@@ -114,22 +115,16 @@ function operationObservation(bridge, operationID) {
             catch (error) {
                 if (options.signal?.aborted)
                     throw operationWaitAborted();
-                if (!(error instanceof PluginBridgeError) || error.errorCode !== "PLUGIN_OPERATION_RATE_LIMITED")
-                    throw error;
-                const retryAfterMS = operationRetryAfterMS(error.details);
-                await operationWaitDelay(Math.max(pollIntervalMs, retryAfterMS), deadline, options.signal);
-                pollIntervalMs = Math.min(10_000, Math.ceil(pollIntervalMs * 1.5));
-                continue;
+                throw error;
             }
             switch (current.status) {
                 case "completed":
                 case "failed":
                 case "canceled":
-                case "orphaned_after_disable":
-                case "orphaned_after_uninstall":
+                case "orphaned":
                     return { status: current.status, snapshot: current };
                 default:
-                    await operationWaitDelay(Math.max(pollIntervalMs, current.retry_after_ms), deadline, options.signal);
+                    await operationWaitDelay(pollIntervalMs, deadline, options.signal);
                     pollIntervalMs = Math.min(10_000, Math.ceil(pollIntervalMs * 1.5));
             }
         }
@@ -165,14 +160,6 @@ async function operationSnapshotUntilDeadline(snapshot, deadline, signal) {
         signal?.removeEventListener("abort", onAbort);
     }
 }
-function operationRetryAfterMS(details) {
-    if (details && typeof details === "object" && !Array.isArray(details)) {
-        const retryAfterMS = details.retry_after_ms;
-        if (Number.isInteger(retryAfterMS) && Number(retryAfterMS) >= 500 && Number(retryAfterMS) <= 10_000)
-            return Number(retryAfterMS);
-    }
-    return 500;
-}
 function operationWaitAborted() {
     return new PluginBridgeError("PLUGIN_BRIDGE_CANCELLED", "Plugin operation observation was cancelled");
 }
@@ -204,19 +191,35 @@ function operationWaitDelay(delayMs, deadline, signal) {
     });
 }
 function decodeCapabilityStreamBatch(method, batch, eventTypeName, eventSchema) {
-    const events = batch.events.map((event) => decodeCapabilityStreamEvent(method, event, eventTypeName, eventSchema));
-    if (batch.done) {
-        return { events, done: true, terminal_status: batch.terminal_status, retry_after_ms: 0 };
+    const events = [];
+    let done = false;
+    for (const event of batch.events) {
+        if (event.kind === "terminal") {
+            const status = event.payload?.status;
+            if (status !== "completed" && status !== "canceled" && status !== "failed" && status !== "orphaned") {
+                throw contractMismatch(method, "stream terminal event has an invalid status");
+            }
+            done = true;
+            if (status === "failed" || status === "orphaned") {
+                throw new PluginBridgeError("PLUGIN_STREAM_FAILED", `Plugin stream terminated with status ${status}`, undefined, {
+                    execution_id: event.execution_id,
+                    status,
+                    failure_code: event.error?.code,
+                });
+            }
+            continue;
+        }
+        events.push(decodeCapabilityStreamEvent(method, event, eventTypeName, eventSchema));
     }
-    return { events, done: false, retry_after_ms: batch.retry_after_ms };
+    return { events, done, cursor: batch.cursor };
 }
 function decodeCapabilityStreamEvent(method, event, eventTypeName, eventSchema) {
-    if (event.kind !== eventTypeName || event.error !== undefined || event.data === undefined) {
+    if (event.kind !== "data" || event.error !== undefined || event.payload?.event_type !== eventTypeName || typeof event.payload.data !== "string") {
         throw contractMismatch(method, "stream event envelope does not match its published contract");
     }
     let value;
     try {
-        value = JSON.parse(decodePluginStreamText(event));
+        value = JSON.parse(decodePluginEventText(event));
     }
     catch {
         throw contractMismatch(method, "stream event is not canonical JSON");
@@ -226,9 +229,9 @@ function decodeCapabilityStreamEvent(method, event, eventTypeName, eventSchema)
     }
     return Object.freeze({
         sequence: event.sequence,
+        execution_id: event.execution_id,
         kind: event.kind,
         data: value,
-        at: event.at,
     });
 }
 function parseSyncResult(method, value) {
@@ -237,37 +240,36 @@ function parseSyncResult(method, value) {
     return value;
 }
 function parseOperationResult(method, value) {
-    if (!hasExactKeys(value, ["data", "operation_id"]) || !validOpaqueIdentifier(value.operation_id, "operation")) {
+    if (!hasExactKeys(value, ["data", "execution_id"]) || !validOpaqueIdentifier(value.execution_id, "execution")) {
         throw contractMismatch(method, "returned an invalid operation result envelope");
     }
-    return { data: value.data, operation_id: value.operation_id };
+    return { data: value.data, execution_id: value.execution_id };
 }
 function parseStreamResult(method, value) {
-    if (!hasExactKeys(value, ["data", "operation_id", "stream_handle"]) ||
-        !validOpaqueIdentifier(value.operation_id, "operation") || !validOpaqueIdentifier(value.stream_handle, "stream")) {
+    if (!hasExactKeys(value, ["data", "execution_id"]) || !validOpaqueIdentifier(value.execution_id, "execution")) {
         throw contractMismatch(method, "returned an invalid subscription result envelope");
     }
-    return { data: value.data, operation_id: value.operation_id, stream_handle: value.stream_handle };
+    return { data: value.data, execution_id: value.execution_id };
 }
-async function cancelAfterResponseMismatch(bridge, operationID, mismatch) {
+async function cancelAfterResponseMismatch(bridge, executionID, mismatch) {
     try {
-        await bridge.cancelOperation(operationID, "response_contract_mismatch");
+        await bridge.cancelExecution(executionID, "response_contract_mismatch");
     }
     catch (cleanupError) {
         throw new PluginBridgeError("PLUGIN_CONTRACT_MISMATCH", "Capability response failed validation and its live operation could not be cancelled", undefined, {
-            operation_id: operationID,
+            execution_id: executionID,
             cleanup_error: cleanupError instanceof Error ? cleanupError.message : String(cleanupError),
         });
     }
     throw mismatch;
 }
-async function cancelAfterStreamMismatch(bridge, operationID, mismatch) {
+async function cancelAfterStreamMismatch(bridge, executionID, mismatch) {
     try {
-        await bridge.cancelOperation(operationID, "stream_contract_mismatch");
+        await bridge.cancelExecution(executionID, "stream_contract_mismatch");
     }
     catch (cleanupError) {
         throw new PluginBridgeError("PLUGIN_CONTRACT_MISMATCH", "Capability stream failed validation and its live operation could not be cancelled", undefined, {
-            operation_id: operationID,
+            execution_id: executionID,
             cleanup_error: cleanupError instanceof Error ? cleanupError.message : String(cleanupError),
         });
     }
@@ -612,11 +614,6 @@ function hasExactKeys(value, keys) {
 function validOpaqueIdentifier(value, prefix) {
     return typeof value === "string" && value.startsWith(`${prefix}_`) && value.length >= 8 && value.length <= 160 && /^[-A-Za-z0-9_]+$/.test(value);
 }
-function pluginStreamTerminalError(status) {
-    if (status === "failed")
-        return new PluginBridgeError("PLUGIN_STREAM_FAILED", "Plugin stream execution failed");
-    return new PluginBridgeError("PLUGIN_STREAM_CANCELLED", `Plugin stream ended with status ${status}`);
-}
 const prototypeSensitivePropertyNames = new Set(["__proto__", "constructor", "prototype"]);
 function contractMismatch(method, detail) {
     return new PluginBridgeError("PLUGIN_CONTRACT_MISMATCH", `Capability method ${method} ${detail}`);

package/dist/contracts.gen.d.ts

@@ -21,14 +21,6 @@ export declare const redevPluginContractVersions: {
     readonly release_source_policy_pointer_schema_version: "release-source-policy-pointer-v2";
     readonly release_revocation_schema_version: "release-revocation-v3";
     readonly release_revocation_pointer_schema_version: "release-revocation-pointer-v2";
-    readonly release_trust_state_schema_version: "release-trust-state-v1";
-    readonly trusted_time_evidence_schema_version: "trusted-time-evidence-v1";
-    readonly trusted_time_leaf_schema_version: "trusted-time-leaf-v1";
-    readonly release_signing_ledger_schema_version: "release-signing-ledger-v1";
-    readonly release_signing_subject_schema_version: "release-signing-subject-v1";
-    readonly release_signature_envelope_schema_version: "release-signature-envelope-v1";
-    readonly release_signing_ledger_receipt_schema_version: "release-signing-ledger-receipt-v1";
-    readonly release_signing_ledger_evidence_schema_version: "release-signing-ledger-evidence-v1";
     readonly token_ticket_schema_version: "token-ticket-v4";
     readonly bridge_schema_version: "bridge-v7";
     readonly opaque_surface_document_schema_version: "opaque-surface-document-v3";
@@ -37,22 +29,17 @@ export declare const redevPluginContractVersions: {
     readonly network_grant_schema_version: "network-grant-v2";
     readonly resource_scope_schema_version: "resource-scope-v1";
     readonly session_scope_schema_version: "session-scope-v1";
-    readonly session_scope_maintenance_schema_version: "session-scope-maintenance-v1";
     readonly plugin_platform_openapi_version: "plugin-platform-v15";
     readonly compatibility_manifest_version: "redevplugin.compatibility.v17";
     readonly compatibility_schema_version: "compatibility-manifest-v17";
     readonly worker_invocation_schema_version: "worker-invocation-v3";
     readonly host_capability_contract_schema_version: "host-capability-contract-v1";
     readonly host_capability_pin_schema_version: "host-capability-pin-v1";
-    readonly host_capability_manifest_schema_version: "host-capability-manifest-v1";
-    readonly host_capability_compatibility_schema_version: "host-capability-compatibility-v1";
-    readonly host_capability_signature_schema_version: "host-capability-signature-v1";
-    readonly host_capability_notices_schema_version: "host-capability-notices-v1";
     readonly error_codes_schema_version: "error-codes-v8";
     readonly performance_contract_version: "performance-contract-v4";
     readonly performance_evidence_schema_version: "performance-evidence-v4";
     readonly contract_registry_version: "contract-registry-v2";
-    readonly platform_package_set_schema_version: "platform-package-set-v1";
+    readonly platform_package_set_schema_version: "platform-package-set-v2";
     readonly platform_package_publication_schema_version: "platform-package-publication-v1";
     readonly runtime_admission_schema_version: "runtime-admission-v1";
     readonly runtime_descriptor_schema_version: "runtime-descriptor-v2";
@@ -74,77 +61,42 @@ export declare const redevPluginContractArtifacts: readonly [{
     readonly id: "compatibility-manifest-schema";
     readonly path: "spec/plugin/compatibility-manifest-v17.schema.json";
     readonly version: "compatibility-manifest-v17";
-    readonly sha256: "f3d726ab1aa4de61acba453ed2511511c51749f67e614f422dcf525fb687ad6e";
+    readonly sha256: "bc426e034b86ef81f947cae6c2fee838d22913c0066f727acb509fa9cbc22ebd";
 }, {
     readonly id: "contract-registry-schema";
     readonly path: "spec/plugin/contract-registry-v2.schema.json";
     readonly version: "contract-registry-v2";
-    readonly sha256: "d516b3565158ac1b0d5e9f86b91b13ac19321ab3ff54468be41951b68d7085ac";
+    readonly sha256: "664a80c4cb8e6fc30a46be56d66b40eed8f0a894e7ceb469757bdffe93b4ee97";
 }, {
     readonly id: "error-codes-schema";
     readonly path: "spec/plugin/error-codes-v8.schema.json";
     readonly version: "error-codes-v8";
-    readonly sha256: "454e3c8b46e20bc524080ca1aa91dcf2ecdfe0a90cc33b5b328e87356d07e7e3";
+    readonly sha256: "5ec127f0fdd6e749d8ee342e53796acd04d1c220fb03cca462bd5222c57b5944";
 }, {
     readonly id: "external-signer-request-schema";
     readonly path: "spec/plugin/external-signer-request-v1.schema.json";
     readonly version: "external-signer-request-v1";
-    readonly sha256: "abc18af2e29dea6f0b49a28b75b046ef02f200597978c8238cc587fb7e670760";
+    readonly sha256: "56884e9bb0b00d07fe7e8c52acfc33a4a7bab54f8a02d504f35b00bab42a03fb";
 }, {
     readonly id: "external-signer-response-schema";
     readonly path: "spec/plugin/external-signer-response-v1.schema.json";
     readonly version: "external-signer-response-v1";
-    readonly sha256: "bbe657df5afdf459a4c5f83282ddc3ec6c80c1ebd25bb954eac92101f35afc6c";
-}, {
-    readonly id: "host-capability-compatibility-schema";
-    readonly path: "spec/plugin/host-capability-compatibility-v1.schema.json";
-    readonly version: "host-capability-compatibility-v1";
-    readonly sha256: "361ebbf7009aeb66c763ecde46427b17b6cf7d2307c01886c5987a1f4f1762de";
+    readonly sha256: "b3b6d2b3dfe4f9bb680387e4c3a8010faef91d2d12fe28e76e51d5d84703a047";
 }, {
     readonly id: "host-capability-contract-schema";
     readonly path: "spec/plugin/host-capability-contract-v1.schema.json";
     readonly version: "host-capability-contract-v1";
     readonly sha256: "0a653e36d44104f1d16b06ee424648086c146f23c907b176bdf470ae73025485";
-}, {
-    readonly id: "host-capability-manifest-schema";
-    readonly path: "spec/plugin/host-capability-manifest-v1.schema.json";
-    readonly version: "host-capability-manifest-v1";
-    readonly sha256: "5f13a8e5f918378b9cba9fdc133a9a75ba3a8311c30cb6a02ca0aba09035110e";
-}, {
-    readonly id: "host-capability-notices-schema";
-    readonly path: "spec/plugin/host-capability-notices-v1.schema.json";
-    readonly version: "host-capability-notices-v1";
-    readonly sha256: "6affd5d0ae90239f6fd08cbeddae4eef393efa2838c9e4935874ba3dc0e05948";
 }, {
     readonly id: "host-capability-pin-schema";
     readonly path: "spec/plugin/host-capability-pin-v1.schema.json";
     readonly version: "host-capability-pin-v1";
-    readonly sha256: "20526a5934f0d85a3db7882492487266f09de5bcd176e2c7936f05d0b7fe0338";
-}, {
-    readonly id: "host-capability-publisher-config-schema";
-    readonly path: "spec/plugin/host-capability-publisher-config-v1.schema.json";
-    readonly version: "host-capability-publisher-config-v1";
-    readonly sha256: "f06ab3d70f3f9dd2114fe9d489841f1d6b5f169ee17b8c92aa1bfaf9bbf865c4";
-}, {
-    readonly id: "host-capability-signature-schema";
-    readonly path: "spec/plugin/host-capability-signature-v1.schema.json";
-    readonly version: "host-capability-signature-v1";
-    readonly sha256: "88cbc1d63afb7e289ca4f8b7c76f702b8d20156f7722c1b71f3ab9138a240a5e";
-}, {
-    readonly id: "host-capability-signer-request-schema";
-    readonly path: "spec/plugin/host-capability-signer-request-v1.schema.json";
-    readonly version: "host-capability-signer-request-v1";
-    readonly sha256: "7f22e9e0f813b91106693edfbb91309489dde1640152c29d878961fdef6b89d8";
-}, {
-    readonly id: "host-capability-signer-response-schema";
-    readonly path: "spec/plugin/host-capability-signer-response-v1.schema.json";
-    readonly version: "host-capability-signer-response-v1";
-    readonly sha256: "02a50b1fc0d1b8ae0611eab95b5560122c6425709ecc8de5e00bf0dd68085f44";
+    readonly sha256: "23591639475c485134c842cae5e53a679dde1b30374a6430ce6e4827be4d18ed";
 }, {
     readonly id: "iframe-bridge-schema";
     readonly path: "spec/plugin/bridge-v7.schema.json";
     readonly version: "bridge-v7";
-    readonly sha256: "fe8da4e5b14ac6d7c7bb3101e041246e92573c58e1c9537e8cda2c26bf175ef5";
+    readonly sha256: "5a6e7307f1649eb70d13e83e5d16177458957bffb3262b9299b4cf6d443e284a";
 }, {
     readonly id: "manifest-schema";
     readonly path: "spec/plugin/manifest-v8.schema.json";
@@ -194,7 +146,7 @@ export declare const redevPluginContractArtifacts: readonly [{
     readonly id: "performance-contract";
     readonly path: "spec/plugin/performance-contract-v4.json";
     readonly version: "performance-contract-v4";
-    readonly sha256: "aedc50ed8899346140965dc46e8adf2048c47bcf6c146c3b7a51646eda7725e1";
+    readonly sha256: "c0c8b3362e6f5878c12dbd0a5766592425d4e69b50ca18c226b6f5851d2c627c";
 }, {
     readonly id: "performance-evidence-schema";
     readonly path: "spec/plugin/performance-evidence-v4.schema.json";
@@ -204,17 +156,17 @@ export declare const redevPluginContractArtifacts: readonly [{
     readonly id: "platform-package-publication-schema";
     readonly path: "spec/plugin/platform-package-publication-v1.schema.json";
     readonly version: "platform-package-publication-v1";
-    readonly sha256: "20450b516c34d5a122020f4064ddfa03ffcb97ffea661e0868cd09760b3f08b0";
+    readonly sha256: "0f4b6788858c3165b6acc94aeab4f771825317f8b05d82d3d202c5848c3f8fdd";
 }, {
     readonly id: "platform-package-set-schema";
-    readonly path: "spec/plugin/platform-package-set-v1.schema.json";
-    readonly version: "platform-package-set-v1";
-    readonly sha256: "4d9979f5205ec047895b64c995312c588d998bb1c1448f6c9c559f1b7ab0d796";
+    readonly path: "spec/plugin/platform-package-set-v2.schema.json";
+    readonly version: "platform-package-set-v2";
+    readonly sha256: "ce46ba85443349481d7cf4b73fc70be716035c369e833aaaf2650710536f3ea8";
 }, {
     readonly id: "plugin-platform-openapi";
     readonly path: "spec/openapi/plugin-platform-v15.yaml";
     readonly version: "plugin-platform-v15";
-    readonly sha256: "10833d303573e1e36816d68db8075543598782df60eda4da44ceed3279d4368c";
+    readonly sha256: "0c95cbb1352040a90acfd63109fb0e41ac452e36ab03a1c6645097d408344d48";
 }, {
     readonly id: "presentation-icon-evidence-schema";
     readonly path: "spec/plugin/presentation-icon-evidence-v1.schema.json";
@@ -234,7 +186,7 @@ export declare const redevPluginContractArtifacts: readonly [{
     readonly id: "publisher-release-ref-schema";
     readonly path: "spec/plugin/publisher-release-ref-v1.schema.json";
     readonly version: "publisher-release-ref-v1";
-    readonly sha256: "f9fd40c87197064ffa3e21a361780a4d057b51df2e886988aac64279785acdc0";
+    readonly sha256: "f68241937dc291b1f660c2c184bd60a7058a4471d2966bd7954ba574c84fe726";
 }, {
     readonly id: "quarantine-cleanup-schema";
     readonly path: "spec/plugin/quarantine-cleanup-v1.schema.json";
@@ -244,67 +196,37 @@ export declare const redevPluginContractArtifacts: readonly [{
     readonly id: "release-metadata-schema";
     readonly path: "spec/plugin/release-metadata-v8.schema.json";
     readonly version: "release-metadata-v8";
-    readonly sha256: "f454fc1923be10fd5a4b46df4a6e376f7e9fe1d462f3da57977b92ad7c7496b0";
+    readonly sha256: "ad8888e6b5673786ea0fc82475be92835c3b177b685cca5bb3efd936d461b215";
 }, {
     readonly id: "release-publisher-config-schema";
     readonly path: "spec/plugin/release-publisher-config-v1.schema.json";
     readonly version: "release-publisher-config-v1";
-    readonly sha256: "c18b11489f81ac657c8324ed344b88b61b259981383ee7b4f9f0b65603a171f8";
+    readonly sha256: "47d782062652b85a77dc67a98c8859f2f1dc598d4496df13ca70c4ceb02df227";
 }, {
     readonly id: "release-revocation-pointer-schema";
     readonly path: "spec/plugin/release-revocation-pointer-v2.schema.json";
     readonly version: "release-revocation-pointer-v2";
-    readonly sha256: "dd39ba618ab02698f135875305d4aa6eb562af7d15520c4ad312cd82e9a7032b";
+    readonly sha256: "51ced7ca790d7d3d3dcb2e65faf3a3a74713ccefe7b2a5b97355a0b3226bdf34";
 }, {
     readonly id: "release-revocation-schema";
     readonly path: "spec/plugin/release-revocation-v3.schema.json";
     readonly version: "release-revocation-v3";
-    readonly sha256: "bd2ca3ab93f047897d3b377adc7fa8b073fc946539a0c5495def1e64915a782b";
+    readonly sha256: "930d2729719f5f44de108df23e9efbbae17f7a3072963c1c5471197b189aa8d9";
 }, {
     readonly id: "release-root-delegation-schema";
     readonly path: "spec/plugin/release-root-delegation-v1.schema.json";
     readonly version: "release-root-delegation-v1";
-    readonly sha256: "c1adbb13eaeeca145d5ee787ff43777e60a5f329e460d20b8db358e4f5fc4825";
-}, {
-    readonly id: "release-signature-envelope-schema";
-    readonly path: "spec/plugin/release-signature-envelope-v1.schema.json";
-    readonly version: "release-signature-envelope-v1";
-    readonly sha256: "7df9afd22bfdebfa89dc3bdb46ecdbe22a91ecce35fa46c492dd9795c66fae29";
-}, {
-    readonly id: "release-signing-ledger-evidence-schema";
-    readonly path: "spec/plugin/release-signing-ledger-evidence-v1.schema.json";
-    readonly version: "release-signing-ledger-evidence-v1";
-    readonly sha256: "9ab8b7f65dedcd119d578debb4f6ff97fc35f4c7ac95c0e5435f8b0959bc1a5c";
-}, {
-    readonly id: "release-signing-ledger-receipt-schema";
-    readonly path: "spec/plugin/release-signing-ledger-receipt-v1.schema.json";
-    readonly version: "release-signing-ledger-receipt-v1";
-    readonly sha256: "29210cfefd967017c5c74bcf8489bd50511c5c9f36d17b0200056ccb90c30561";
-}, {
-    readonly id: "release-signing-ledger-schema";
-    readonly path: "spec/plugin/release-signing-ledger-v1.schema.json";
-    readonly version: "release-signing-ledger-v1";
-    readonly sha256: "0c72b30bfd6b857b9809e48e1b7eaaeb7134d5afd6a935aa8373465054403765";
-}, {
-    readonly id: "release-signing-subject-schema";
-    readonly path: "spec/plugin/release-signing-subject-v1.schema.json";
-    readonly version: "release-signing-subject-v1";
-    readonly sha256: "876b1459824f90042bd141e96bfea4633333bdf2a227e15b6e25c72db1179c8e";
+    readonly sha256: "f46249f9d51610b7a8401adc4ed04c098adaad408f35661b092f8d67767e21f2";
 }, {
     readonly id: "release-source-policy-pointer-schema";
     readonly path: "spec/plugin/release-source-policy-pointer-v2.schema.json";
     readonly version: "release-source-policy-pointer-v2";
-    readonly sha256: "735659143db7204abdd20c6fbc994ac7474618c41b85949aad4c28fb2912e034";
+    readonly sha256: "a4b2ba0909a633cfd0a365dff87ca1b6eaf6df53ac38b4d2b458d7ea85da6dd1";
 }, {
     readonly id: "release-source-policy-schema";
     readonly path: "spec/plugin/release-source-policy-v3.schema.json";
     readonly version: "release-source-policy-v3";
-    readonly sha256: "8814de028800c92b26c8c85a06298762598aeba1835f57048ec6c06430f8567b";
-}, {
-    readonly id: "release-trust-state-schema";
-    readonly path: "spec/plugin/release-trust-state-v1.schema.json";
-    readonly version: "release-trust-state-v1";
-    readonly sha256: "19ffa182932a22401a33ee4c9921e957c67895c2d8b041c9a27ee3530bdfb2d2";
+    readonly sha256: "9b6964cbbaeab6400ab25ff3da6fca891b9833c7f644f56367b420382d096244";
 }, {
     readonly id: "resource-scope-schema";
     readonly path: "spec/plugin/resource-scope-v1.schema.json";
@@ -329,17 +251,12 @@ export declare const redevPluginContractArtifacts: readonly [{
     readonly id: "rust-ipc-schema";
     readonly path: "spec/plugin/ipc-v6.schema.json";
     readonly version: "rust-ipc-v6";
-    readonly sha256: "9814ca091ac2e4e8435c1ab553e248e9d2e792de93ce9fd27bd030486774837f";
-}, {
-    readonly id: "session-scope-maintenance-contract";
-    readonly path: "spec/plugin/session-scope-maintenance-v1.json";
-    readonly version: "session-scope-maintenance-v1";
-    readonly sha256: "fd87b6654c954ee2a2dc67958ba214048b894aa421bb74a85fb02000ec51f37b";
+    readonly sha256: "75d7fb83d4502be726e986025f7ec14fac592bcaeb7add6b28dff42a7360c5dc";
 }, {
     readonly id: "session-scope-schema";
     readonly path: "spec/plugin/session-scope-v1.schema.json";
     readonly version: "session-scope-v1";
-    readonly sha256: "3df0084264f0aff9fe2261c237cea439adb5cdc2534bfaaa0488d5992d4a7d2e";
+    readonly sha256: "38044d65de36ce5219929ac4080547660734a7c6bb4d26d9b90e5838b1db331a";
 }, {
     readonly id: "target-classifier-fixture";
     readonly path: "spec/plugin/target-classifier-v2.json";
@@ -349,17 +266,7 @@ export declare const redevPluginContractArtifacts: readonly [{
     readonly id: "token-ticket-schema";
     readonly path: "spec/plugin/token-ticket-v4.schema.json";
     readonly version: "token-ticket-v4";
-    readonly sha256: "5cf365b5b52a331ac0d3ad35a98be3c2ce668804ae88fdeaf9679a44db14feb1";
-}, {
-    readonly id: "trusted-time-evidence-schema";
-    readonly path: "spec/plugin/trusted-time-evidence-v1.schema.json";
-    readonly version: "trusted-time-evidence-v1";
-    readonly sha256: "4398cbd2a3eea42a85008ee16a69d7adb265673e6749b1f13a4f1610f36e5e38";
-}, {
-    readonly id: "trusted-time-leaf-schema";
-    readonly path: "spec/plugin/trusted-time-leaf-v1.schema.json";
-    readonly version: "trusted-time-leaf-v1";
-    readonly sha256: "1c25eb0040800eef145aa2bb4c0e1ae197ae584d365e9595ab89037e26fe5ddb";
+    readonly sha256: "1576e35e4e06ba67c2fdc038934c5d5184fd1224adbd75c9f8eaf6a144ade238";
 }, {
     readonly id: "wasm-worker-schema";
     readonly path: "spec/plugin/wasm-worker-v2.schema.json";
@@ -369,5 +276,5 @@ export declare const redevPluginContractArtifacts: readonly [{
     readonly id: "worker-invocation-schema";
     readonly path: "spec/plugin/worker-invocation-v3.schema.json";
     readonly version: "worker-invocation-v3";
-    readonly sha256: "f08af491cbf5e7b71d1aeafbeac9ae581ee5fc3bcb76184daec369f94bab3927";
+    readonly sha256: "f75b5b6ea0f5936e15f84a76d9b496690d7e1b7da7a05948ad26a88cc1360847";
 }];