@floegence/redevplugin-ui 0.2.1 → 0.3.0

package/dist/capability-client.d.ts

@@ -0,0 +1,40 @@
+import { PluginBridgeError } from "./errors.js";
+import type { PluginBridgeClient, PluginJSONObject, PluginStreamEvent as PluginRawStreamEvent, PluginStreamTerminalStatus } from "./surface.js";
+export type PluginCapabilitySchema = Readonly<Record<string, unknown>>;
+export type PluginCapabilityBusinessErrorSpec = {
+    detail_schema_sha256: string;
+    schema: PluginCapabilitySchema | null;
+};
+export type PluginOperation<T, Cancelable extends boolean = true> = {
+    data: T;
+    operation_id: string;
+} & (Cancelable extends true ? {
+    cancel(reason?: string): Promise<void>;
+} : Record<never, never>);
+export type PluginCapabilityStreamEvent<Event> = Omit<PluginRawStreamEvent, "data" | "error"> & {
+    data: Event;
+};
+export type PluginCapabilityStreamReadResult<Event> = {
+    events: PluginCapabilityStreamEvent<Event>[];
+    done: false;
+    retry_after_ms: number;
+} | {
+    events: PluginCapabilityStreamEvent<Event>[];
+    done: true;
+    terminal_status: PluginStreamTerminalStatus;
+    retry_after_ms: 0;
+};
+export type PluginStream<Initial, Event> = {
+    data: Initial;
+    operation_id: string;
+    stream_handle: string;
+    read(): Promise<PluginCapabilityStreamReadResult<Event>>;
+    cancel(reason?: string): Promise<void>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<PluginCapabilityStreamEvent<Event>>;
+};
+export declare function callCapabilitySync<Request extends object, Response>(bridge: PluginBridgeClient, method: string, request: Request, requestSchema: PluginCapabilitySchema, responseSchema: PluginCapabilitySchema): Promise<Response>;
+export declare function callCapabilityOperation<Request extends object, Response, Cancelable extends boolean = true>(bridge: PluginBridgeClient, method: string, request: Request, requestSchema: PluginCapabilitySchema, responseSchema: PluginCapabilitySchema, cancelable?: Cancelable): Promise<PluginOperation<Response, Cancelable>>;
+export declare function callCapabilityStream<Request extends object, Response, Event>(bridge: PluginBridgeClient, method: string, request: Request, requestSchema: PluginCapabilitySchema, responseSchema: PluginCapabilitySchema, eventTypeName: string, eventSchema: PluginCapabilitySchema): 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

@@ -0,0 +1,501 @@
+import { PluginBridgeError } from "./errors.js";
+import { decodePluginStreamText } from "./surface.js";
+export async function callCapabilitySync(bridge, method, request, requestSchema, responseSchema) {
+    const params = validateRequest(request, requestSchema);
+    const result = parseSyncResult(method, await bridge.call(method, params));
+    return validateResponse(method, result.data, responseSchema);
+}
+export async function callCapabilityOperation(bridge, method, request, requestSchema, responseSchema, cancelable = true) {
+    const params = validateRequest(request, requestSchema);
+    const result = parseOperationResult(method, await bridge.call(method, params));
+    let data;
+    try {
+        data = validateResponse(method, result.data, responseSchema);
+    }
+    catch (error) {
+        if (cancelable)
+            await cancelAfterResponseMismatch(bridge, result.operation_id, error);
+        throw error;
+    }
+    return Object.freeze({
+        data: data,
+        operation_id: result.operation_id,
+        ...(cancelable ? { cancel: (reason) => bridge.cancelOperation(result.operation_id, reason) } : {}),
+    });
+}
+export async function callCapabilityStream(bridge, method, request, requestSchema, responseSchema, eventTypeName, eventSchema) {
+    const params = validateRequest(request, requestSchema);
+    const result = parseStreamResult(method, await bridge.call(method, params));
+    let data;
+    try {
+        data = validateResponse(method, result.data, responseSchema);
+    }
+    catch (error) {
+        await cancelAfterResponseMismatch(bridge, result.operation_id, error);
+    }
+    let settled = false;
+    const read = async () => {
+        try {
+            const batch = decodeCapabilityStreamBatch(method, await bridge.readStream(result.stream_handle), eventTypeName, eventSchema);
+            if (batch.done)
+                settled = true;
+            return batch;
+        }
+        catch (error) {
+            settled = true;
+            return cancelAfterStreamMismatch(bridge, result.operation_id, error);
+        }
+    };
+    const cancel = async (reason) => {
+        if (settled)
+            return;
+        await bridge.cancelOperation(result.operation_id, reason);
+        settled = true;
+    };
+    return Object.freeze({
+        data: data,
+        operation_id: result.operation_id,
+        stream_handle: result.stream_handle,
+        read,
+        cancel,
+        async *[Symbol.asyncIterator]() {
+            try {
+                while (true) {
+                    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));
+                    }
+                }
+            }
+            finally {
+                if (!settled)
+                    await cancel("stream_iterator_closed");
+            }
+        },
+    });
+}
+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 };
+    }
+    return { events, done: false, retry_after_ms: batch.retry_after_ms };
+}
+function decodeCapabilityStreamEvent(method, event, eventTypeName, eventSchema) {
+    if (event.kind !== eventTypeName || event.error !== undefined || event.data === undefined) {
+        throw contractMismatch(method, "stream event envelope does not match its published contract");
+    }
+    let value;
+    try {
+        value = JSON.parse(decodePluginStreamText(event));
+    }
+    catch {
+        throw contractMismatch(method, "stream event is not canonical JSON");
+    }
+    if (!validateValue(value, eventSchema, new Set())) {
+        throw contractMismatch(method, "stream event does not match its published contract");
+    }
+    return Object.freeze({
+        sequence: event.sequence,
+        kind: event.kind,
+        data: value,
+        at: event.at,
+    });
+}
+function parseSyncResult(method, value) {
+    if (!hasExactKeys(value, ["data"]))
+        throw contractMismatch(method, "returned an invalid sync result envelope");
+    return value;
+}
+function parseOperationResult(method, value) {
+    if (!hasExactKeys(value, ["data", "operation_id"]) || !validOpaqueIdentifier(value.operation_id, "operation")) {
+        throw contractMismatch(method, "returned an invalid operation result envelope");
+    }
+    return { data: value.data, operation_id: value.operation_id };
+}
+function parseStreamResult(method, value) {
+    if (!hasExactKeys(value, ["data", "operation_id", "stream_handle"]) ||
+        !validOpaqueIdentifier(value.operation_id, "operation") || !validOpaqueIdentifier(value.stream_handle, "stream")) {
+        throw contractMismatch(method, "returned an invalid subscription result envelope");
+    }
+    return { data: value.data, operation_id: value.operation_id, stream_handle: value.stream_handle };
+}
+async function cancelAfterResponseMismatch(bridge, operationID, mismatch) {
+    try {
+        await bridge.cancelOperation(operationID, "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,
+            cleanup_error: cleanupError instanceof Error ? cleanupError.message : String(cleanupError),
+        });
+    }
+    throw mismatch;
+}
+async function cancelAfterStreamMismatch(bridge, operationID, mismatch) {
+    try {
+        await bridge.cancelOperation(operationID, "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,
+            cleanup_error: cleanupError instanceof Error ? cleanupError.message : String(cleanupError),
+        });
+    }
+    throw mismatch;
+}
+export function isCapabilityBusinessError(error, capabilityID, capabilityVersion, detailSchemas) {
+    if (!(error instanceof PluginBridgeError) || error.errorCode !== "PLUGIN_CAPABILITY_ERROR" || !isRecord(error.details)) {
+        return false;
+    }
+    if (!Object.keys(error.details).every((key) => key === "capability_id" || key === "capability_version" || key === "detail_schema_sha256" ||
+        key === "business_error_code" || key === "business_error_details")) {
+        return false;
+    }
+    if (error.details.capability_id !== capabilityID || error.details.capability_version !== capabilityVersion)
+        return false;
+    const code = error.details.business_error_code;
+    if (typeof code !== "string" || !Object.hasOwn(detailSchemas, code))
+        return false;
+    const specification = detailSchemas[code];
+    if (error.details.detail_schema_sha256 !== specification.detail_schema_sha256)
+        return false;
+    const schema = specification.schema;
+    if (schema === null)
+        return error.details.business_error_details === undefined;
+    return isRecord(schema) && validateValue(error.details.business_error_details, schema, new Set());
+}
+function validateRequest(request, schema) {
+    if (!validateValue(request, schema, new Set())) {
+        throw new PluginBridgeError("PLUGIN_INVALID_REQUEST", "Capability request does not match its published contract");
+    }
+    return request;
+}
+function validateResponse(method, value, schema) {
+    if (!validateValue(value, schema, new Set())) {
+        throw contractMismatch(method, "response does not match its published contract");
+    }
+    return value;
+}
+function validateValue(value, schema, seen) {
+    if (Array.isArray(schema.oneOf)) {
+        let matches = 0;
+        for (const branch of schema.oneOf) {
+            if (!isRecord(branch))
+                return false;
+            if (validateValue(value, branch, seen))
+                matches += 1;
+        }
+        return matches === 1;
+    }
+    const type = schema.type;
+    if (typeof type !== "string")
+        return false;
+    if (value !== null && typeof value === "object") {
+        if (seen.has(value))
+            return false;
+        seen.add(value);
+    }
+    try {
+        switch (type) {
+            case "object":
+                return validateObject(value, schema, seen);
+            case "array":
+                return validateArray(value, schema, seen);
+            case "string":
+                return validateString(value, schema);
+            case "integer":
+                return typeof value === "number" && Number.isSafeInteger(value) && validateNumber(value, schema);
+            case "number":
+                return typeof value === "number" && Number.isFinite(value) && validateNumber(value, schema);
+            case "boolean":
+                return typeof value === "boolean" && validateConst(value, schema);
+            case "null":
+                return value === null;
+            default:
+                return false;
+        }
+    }
+    finally {
+        if (value !== null && typeof value === "object")
+            seen.delete(value);
+    }
+}
+function validateObject(value, schema, seen) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return false;
+    if (schema.additionalProperties !== false || (schema.properties !== undefined && !isRecord(schema.properties)))
+        return false;
+    const object = value;
+    const properties = (schema.properties ?? {});
+    const required = Array.isArray(schema.required) ? schema.required : [];
+    if (required.some((name) => typeof name !== "string" || !Object.hasOwn(object, name)))
+        return false;
+    const keys = Object.keys(object);
+    if (keys.some((key) => prototypeSensitivePropertyNames.has(key)) ||
+        Object.keys(properties).some((key) => prototypeSensitivePropertyNames.has(key)))
+        return false;
+    if (!integerBound(keys.length, schema.minProperties, schema.maxProperties))
+        return false;
+    for (const key of keys) {
+        const child = properties[key];
+        if (!isRecord(child) || !validateValue(object[key], child, seen))
+            return false;
+    }
+    return true;
+}
+function validateArray(value, schema, seen) {
+    if (!Array.isArray(value) || !isRecord(schema.items))
+        return false;
+    if (!integerBound(value.length, schema.minItems, schema.maxItems))
+        return false;
+    if (schema.uniqueItems === true) {
+        const canonical = value.map(canonicalJSONKey);
+        if (new Set(canonical).size !== canonical.length)
+            return false;
+    }
+    return value.every((item) => validateValue(item, schema.items, seen));
+}
+function validateString(value, schema) {
+    if (typeof value !== "string" || !integerBound(Array.from(value).length, schema.minLength, schema.maxLength) || !validateConst(value, schema)) {
+        return false;
+    }
+    if (Array.isArray(schema.enum) && !schema.enum.includes(value))
+        return false;
+    if (typeof schema.pattern === "string") {
+        try {
+            if (!isPortablePattern(schema.pattern))
+                return false;
+            const match = new RegExp(schema.pattern, "u").exec(value);
+            if (match === null || match.index !== 0 || match[0].length !== value.length)
+                return false;
+        }
+        catch {
+            return false;
+        }
+    }
+    if (typeof schema.format === "string" && !validateStringFormat(value, schema.format))
+        return false;
+    return true;
+}
+function validateStringFormat(value, format) {
+    switch (format) {
+        case "date-time":
+            return validateDateTime(value);
+        case "uuid":
+            return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+        case "hostname":
+            return validateHostname(value);
+        case "ipv4":
+            return validateIPv4(value);
+        case "ipv6":
+            return validateIPv6(value);
+        default:
+            return false;
+    }
+}
+function validateDateTime(value) {
+    const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d+)?(Z|[+-]\d{2}:\d{2})$/.exec(value);
+    if (match === null || Number(match[4]) > 23 || Number(match[5]) > 59 || Number(match[6]) > 59)
+        return false;
+    const month = Number(match[2]);
+    const day = Number(match[3]);
+    const offset = match[7];
+    if (offset !== "Z") {
+        const offsetHours = Number(offset.slice(1, 3));
+        const offsetMinutes = Number(offset.slice(4, 6));
+        if (offsetHours > 23 || offsetMinutes > 59)
+            return false;
+    }
+    return Number.isFinite(Date.parse(value)) && month >= 1 && month <= 12 && day >= 1 && day <= new Date(Date.UTC(Number(match[1]), month, 0)).getUTCDate();
+}
+function validateHostname(value) {
+    if (value.length === 0 || value.length > 253 || value.endsWith("."))
+        return false;
+    return value.split(".").every((label) => label.length >= 1 && label.length <= 63 && /^[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?$/.test(label));
+}
+function validateIPv4(value) {
+    const parts = value.split(".");
+    return parts.length === 4 && parts.every((part) => /^(?:0|[1-9]\d{0,2})$/.test(part) && Number(part) <= 255);
+}
+function validateIPv6(value) {
+    if (value.length === 0 || value.includes(":::"))
+        return false;
+    const compression = value.indexOf("::");
+    if (compression !== value.lastIndexOf("::"))
+        return false;
+    const [leftRaw, rightRaw = ""] = compression >= 0 ? value.split("::") : [value, ""];
+    const left = leftRaw === "" ? [] : leftRaw.split(":");
+    const right = rightRaw === "" ? [] : rightRaw.split(":");
+    const parseSide = (parts, allowIPv4) => {
+        let groups = 0;
+        for (let index = 0; index < parts.length; index += 1) {
+            const part = parts[index];
+            if (part.includes(".")) {
+                if (!allowIPv4 || index !== parts.length - 1 || !validateIPv4(part))
+                    return null;
+                groups += 2;
+            }
+            else {
+                if (!/^[0-9A-Fa-f]{1,4}$/.test(part))
+                    return null;
+                groups += 1;
+            }
+        }
+        return groups;
+    };
+    const leftGroups = parseSide(left, right.length === 0);
+    const rightGroups = parseSide(right, true);
+    if (leftGroups === null || rightGroups === null)
+        return false;
+    const groups = leftGroups + rightGroups;
+    return compression >= 0 ? groups < 8 : groups === 8;
+}
+function validateNumber(value, schema) {
+    if (!validateConst(value, schema))
+        return false;
+    if (Array.isArray(schema.enum) && !schema.enum.includes(value))
+        return false;
+    if (typeof schema.minimum === "number" && value < schema.minimum)
+        return false;
+    if (typeof schema.maximum === "number" && value > schema.maximum)
+        return false;
+    if (typeof schema.exclusiveMinimum === "number" && value <= schema.exclusiveMinimum)
+        return false;
+    if (typeof schema.exclusiveMaximum === "number" && value >= schema.exclusiveMaximum)
+        return false;
+    if (typeof schema.multipleOf === "number" && !isJSONMultipleOf(value, schema.multipleOf))
+        return false;
+    return true;
+}
+function isJSONMultipleOf(value, divisor) {
+    if (!Number.isFinite(divisor) || divisor <= 0)
+        return false;
+    const left = decimalCoefficient(value);
+    const right = decimalCoefficient(divisor);
+    if (left === null || right === null || right.coefficient === 0n)
+        return false;
+    let numerator = left.coefficient;
+    let denominator = right.coefficient;
+    const difference = right.scale - left.scale;
+    if (difference > 0)
+        numerator *= 10n ** BigInt(difference);
+    if (difference < 0)
+        denominator *= 10n ** BigInt(-difference);
+    return numerator % denominator === 0n;
+}
+function decimalCoefficient(value) {
+    if (!Number.isFinite(value))
+        return null;
+    let text = String(value).toLowerCase();
+    let sign = 1n;
+    if (text.startsWith("-")) {
+        sign = -1n;
+        text = text.slice(1);
+    }
+    let exponent = 0;
+    const exponentIndex = text.indexOf("e");
+    if (exponentIndex >= 0) {
+        exponent = Number(text.slice(exponentIndex + 1));
+        if (!Number.isSafeInteger(exponent))
+            return null;
+        text = text.slice(0, exponentIndex);
+    }
+    let scale = 0;
+    const decimalIndex = text.indexOf(".");
+    if (decimalIndex >= 0) {
+        scale = text.length - decimalIndex - 1;
+        text = text.slice(0, decimalIndex) + text.slice(decimalIndex + 1);
+    }
+    text = text.replace(/^0+/, "") || "0";
+    if (!/^[0-9]+$/.test(text))
+        return null;
+    return { coefficient: BigInt(text) * sign, scale: scale - exponent };
+}
+function isPortablePattern(pattern) {
+    if (!pattern.startsWith("^") || !pattern.endsWith("$") || pattern.length < 3)
+        return false;
+    const body = pattern.slice(1, -1);
+    let index = 0;
+    let atoms = 0;
+    while (index < body.length) {
+        const current = body[index];
+        if (current === "[") {
+            const end = body.indexOf("]", index + 1);
+            if (end < 0 || end === index + 1 || !/^[A-Za-z0-9._~:/-]+$/.test(body.slice(index + 1, end)))
+                return false;
+            index = end + 1;
+        }
+        else if (current === "\\") {
+            if (index + 1 >= body.length || !".\\-".includes(body[index + 1]))
+                return false;
+            index += 2;
+        }
+        else {
+            if (!/^[A-Za-z0-9_~:/-]$/.test(current))
+                return false;
+            index += 1;
+        }
+        atoms += 1;
+        if (index >= body.length)
+            continue;
+        if ("+*?".includes(body[index])) {
+            index += 1;
+            continue;
+        }
+        if (body[index] === "{") {
+            const end = body.indexOf("}", index + 1);
+            if (end < 0 || !/^(?:0|[1-9][0-9]*)(?:,(?:0|[1-9][0-9]*)?)?$/.test(body.slice(index + 1, end)))
+                return false;
+            index = end + 1;
+        }
+    }
+    return atoms > 0;
+}
+function canonicalJSONKey(value) {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJSONKey).join(",")}]`;
+    const record = value;
+    return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonicalJSONKey(record[key])}`).join(",")}}`;
+}
+function validateConst(value, schema) {
+    return !Object.hasOwn(schema, "const") || Object.is(value, schema.const);
+}
+function integerBound(value, minimum, maximum) {
+    if (typeof minimum === "number" && (!Number.isSafeInteger(minimum) || value < minimum))
+        return false;
+    if (typeof maximum === "number" && (!Number.isSafeInteger(maximum) || value > maximum))
+        return false;
+    return true;
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function hasExactKeys(value, keys) {
+    if (!isRecord(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 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

@@ -23,6 +23,12 @@ export declare const redevPluginContractVersions: {
     readonly compatibility_schema_version: "compatibility-manifest-v2";
     readonly release_manifest_schema_version: "release-manifest-v2";
     readonly worker_invocation_schema_version: "worker-invocation-v1";
+    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-v1";
     readonly contract_registry_version: "contract-registry-v1";
 };
@@ -36,12 +42,12 @@ export declare const redevPluginContractArtifacts: readonly [{
     readonly id: "plugin-platform-openapi";
     readonly path: "spec/openapi/plugin-platform-v2.yaml";
     readonly version: "plugin-platform-v2";
-    readonly sha256: "5d6006831c3e55cd9232ad8f9decdc932059193538f9f0ff2b3934d81a6b9aaa";
+    readonly sha256: "b7922ebd37be680060f067b66a439f3d1f9a7f22d730512763e3f7d347dcaf9a";
 }, {
     readonly id: "manifest-schema";
     readonly path: "spec/plugin/manifest-v2.schema.json";
     readonly version: "manifest-v2";
-    readonly sha256: "ba2f782e0e47694484d4112da00d92689187e3bbd1e2f08aca2d9d680e554d51";
+    readonly sha256: "f80279943bde0e304138ee0fdae2e7b9f2b0334412cf159d268cc8badc196759";
 }, {
     readonly id: "package-signature-schema";
     readonly path: "spec/plugin/package-signature-v1.schema.json";
@@ -51,12 +57,12 @@ export declare const redevPluginContractArtifacts: readonly [{
     readonly id: "release-metadata-schema";
     readonly path: "spec/plugin/release-metadata-v2.schema.json";
     readonly version: "release-metadata-v2";
-    readonly sha256: "6f985f9b0f009151b41e878c68f217058f7dd892f7f6471b2e5d24f54d858567";
+    readonly sha256: "5f24cf61bea352715f24595c385745476e677affdaf8f60fd15e534424df60b6";
 }, {
     readonly id: "source-policy-schema";
     readonly path: "spec/plugin/source-policy-v1.schema.json";
     readonly version: "source-policy-v1";
-    readonly sha256: "b5f3094402bdbfdda1671b46e5f64a69ad7dc2ba9501030439fafa87acd2923e";
+    readonly sha256: "fb6a9c27e726378a28a9ff48ee47c40ede99fa95a524a308e2c762bebc4b9fe2";
 }, {
     readonly id: "source-revocations-schema";
     readonly path: "spec/plugin/source-revocations-v1.schema.json";
@@ -66,12 +72,12 @@ export declare const redevPluginContractArtifacts: readonly [{
     readonly id: "token-ticket-schema";
     readonly path: "spec/plugin/token-ticket-v2.schema.json";
     readonly version: "token-ticket-v2";
-    readonly sha256: "f2fa0d5948318a7a61a3e52d1487b308891d65578259d5958b26c59adef0f351";
+    readonly sha256: "f0342614f28b81045ac47d76d71753c8ee177f8143c14a711a0b1f5632e7835e";
 }, {
     readonly id: "iframe-bridge-schema";
     readonly path: "spec/plugin/bridge-v2.schema.json";
     readonly version: "bridge-v2";
-    readonly sha256: "6a6f33381503d67fd7c3098e5e73b8d01ba80b0145190bdd034f85fd43528f23";
+    readonly sha256: "23d968113aaf93dab75df6acd96a350df07c0428fd2a00c66c015a0d875592d1";
 }, {
     readonly id: "opaque-surface-document-schema";
     readonly path: "spec/plugin/opaque-surface-document-v1.schema.json";
@@ -86,7 +92,7 @@ export declare const redevPluginContractArtifacts: readonly [{
     readonly id: "compatibility-manifest-schema";
     readonly path: "spec/plugin/compatibility-manifest-v2.schema.json";
     readonly version: "compatibility-manifest-v2";
-    readonly sha256: "924c117966bfc322b643e2987d1387f15ebd5222f328171c66eb56d24d281e21";
+    readonly sha256: "7e0789cc80f4674277c6d12f4e097198543081b198b7a1a94eefb3cd404c6eb0";
 }, {
     readonly id: "release-manifest-schema";
     readonly path: "spec/plugin/release-manifest-v2.schema.json";
@@ -96,17 +102,47 @@ export declare const redevPluginContractArtifacts: readonly [{
     readonly id: "worker-invocation-schema";
     readonly path: "spec/plugin/worker-invocation-v1.schema.json";
     readonly version: "worker-invocation-v1";
-    readonly sha256: "cbbef78febae6d13d914bf382d22f2d9785d0bac158eb92d18a2815d5c70dbe6";
+    readonly sha256: "9199dd0731aaf592e34c1574cd81c094412a3e6cd9b633853d3e60e89438bcb5";
+}, {
+    readonly id: "host-capability-contract-schema";
+    readonly path: "spec/plugin/host-capability-contract-v1.schema.json";
+    readonly version: "host-capability-contract-v1";
+    readonly sha256: "a2318b01211aa6dbd8ca983f7ebca311619527aa4828a0ea0d201ebac7427292";
+}, {
+    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-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-compatibility-schema";
+    readonly path: "spec/plugin/host-capability-compatibility-v1.schema.json";
+    readonly version: "host-capability-compatibility-v1";
+    readonly sha256: "361ebbf7009aeb66c763ecde46427b17b6cf7d2307c01886c5987a1f4f1762de";
+}, {
+    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-notices-schema";
+    readonly path: "spec/plugin/host-capability-notices-v1.schema.json";
+    readonly version: "host-capability-notices-v1";
+    readonly sha256: "6affd5d0ae90239f6fd08cbeddae4eef393efa2838c9e4935874ba3dc0e05948";
 }, {
     readonly id: "error-codes-schema";
     readonly path: "spec/plugin/error-codes-v1.schema.json";
     readonly version: "error-codes-v1";
-    readonly sha256: "89c95342f689b0ad486631f85ce73d4ffc86babe4e827ac6c2337e50bddc536e";
+    readonly sha256: "254eb4c6d25bae3976c30fe51bdd49456e906e1a3f3bc76df092afd30bd4c948";
 }, {
     readonly id: "rust-ipc-schema";
     readonly path: "spec/plugin/ipc-v1.schema.json";
     readonly version: "rust-ipc-v1";
-    readonly sha256: "4e3a9556392b06b805f36fe80c5690408d702a72d71ac6f6e3edcb31f2fd0e91";
+    readonly sha256: "78f1310a0b48db733301c3f163ada041a3c9daf2d09369860d758296cbe12e39";
 }, {
     readonly id: "wasm-worker-schema";
     readonly path: "spec/plugin/wasm-worker-v1.schema.json";
@@ -126,5 +162,5 @@ export declare const redevPluginContractArtifacts: readonly [{
     readonly id: "contract-registry";
     readonly path: "spec/plugin/contract-registry-v1.json";
     readonly version: "contract-registry-v1";
-    readonly sha256: "753d9e86abc10957ee2a80ae87b5ebf1b83af70370afc1c4e838efa6854eb8f9";
+    readonly sha256: "42dd916922a6183b49d4abc765da2e2d086771a6e6ac1828f8e1dbebb262bba0";
 }];