@trycua/cua-driver 0.23.2 → 0.25.0

package/dist/native/cua_driver_sdk.js

@@ -4,7 +4,7 @@
 /* eslint-disable */
 // @ts-nocheck
 import nativeModule from "./cua_driver_sdk-ffi.js";
-import { AbstractFfiConverterByteArray, FfiConverterArray, FfiConverterBool, FfiConverterInt32, FfiConverterObject, FfiConverterObjectWithCallbacks, FfiConverterOptional, FfiConverterUInt32, FfiConverterUInt64, UniffiAbstractObject, UniffiError, UniffiInternalError, UniffiResult, UniffiRustCaller, destructorGuardSymbol, pointerLiteralSymbol, uniffiCreateFfiConverterString, uniffiCreateRecord, uniffiRustCallAsync, uniffiTraitInterfaceCall, uniffiTraitInterfaceCallAsyncWithError, uniffiTypeNameSymbol, } from "@ubjs/core";
+import { AbstractFfiConverterByteArray, FfiConverterArray, FfiConverterBool, FfiConverterInt32, FfiConverterObject, FfiConverterObjectWithCallbacks, FfiConverterOptional, FfiConverterUInt32, FfiConverterUInt64, UniffiAbstractObject, UniffiError, UniffiInternalError, UniffiResult, UniffiRustCaller, destructorGuardSymbol, pointerLiteralSymbol, uniffiCreateFfiConverterString, uniffiCreateRecord, uniffiRustCallAsync, uniffiTraitInterfaceCall, uniffiTraitInterfaceCallAsyncWithError, uniffiTraitInterfaceCallWithError, uniffiTypeNameSymbol, } from "@ubjs/core";
 import uniffiCuaDriverContractModule from "./cua_driver_contract.js";
 const { FfiConverterTypeActionResult, FfiConverterTypeClickInput, FfiConverterTypeClipboardReadInput, FfiConverterTypeClipboardWriteInput, FfiConverterTypeDragInput, FfiConverterTypeEndSessionInput, FfiConverterTypeEndSessionOutput, FfiConverterTypeEscalateSessionInput, FfiConverterTypeGetAgentCursorStateInput, FfiConverterTypeGetCursorPositionInput, FfiConverterTypeGetDesktopStateInput, FfiConverterTypeGetScreenSizeInput, FfiConverterTypeGetSessionInput, FfiConverterTypeGetSessionStateInput, FfiConverterTypeHotkeyInput, FfiConverterTypeInvokeMenuInput, FfiConverterTypeListSessionsInput, FfiConverterTypeListSessionsOutput, FfiConverterTypeMoveCursorInput, FfiConverterTypePressKeyInput, FfiConverterTypeScrollInput, FfiConverterTypeSessionOutput, FfiConverterTypeSessionStateOutput, FfiConverterTypeSetAgentCursorEnabledInput, FfiConverterTypeSetAgentCursorMotionInput, FfiConverterTypeSetAgentCursorThemeInput, FfiConverterTypeSetWindowFrameInput, FfiConverterTypeStartSessionInput, FfiConverterTypeStartSessionOutput, FfiConverterTypeTypeTextInput, FfiConverterTypeVerifyStateInput, FfiConverterTypeVerifyStateOutput } = uniffiCuaDriverContractModule.converters;
 const uniffiCaller = new UniffiRustCaller(() => ({ code: 0 }));
@@ -15,6 +15,49 @@ typeof process !== "object" ||
     process?.env?.NODE_ENV !== "production" ||
     false;
 // Public interface members begin here.
+/**
+ * Connect the canonical typed Driver to a host-provided remote carrier.
+ */
+export function connectRemoteChannel(channel) {
+    return FfiConverterTypeCuaDriver.lift(uniffiCaller.rustCallWithError(
+    /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
+    /*caller:*/ (callStatus) => {
+        return nativeModule().uniffi_cua_driver_sdk_fn_func_connect_remote_channel(FfiConverterTypeForeignDriverEnvelopeChannel.lower(channel, nativeModule().rustbuffer_alloc), callStatus);
+    }, 
+    /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+}
+/**
+ * Bind a logical remote session without serializing its authority.
+ */
+export async function createRemoteTrustedSession(driver, options, asyncOpts_) {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+        /*rustCaller:*/ uniffiCaller, 
+        /*rustFutureFunc:*/ () => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_func_create_remote_trusted_session(FfiConverterTypeCuaDriver.lower(driver, nativeModule().rustbuffer_alloc), FfiConverterTypeTrustedSessionOptions.lower(options, nativeModule().rustbuffer_alloc));
+        }, 
+        /*pollFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_poll_u64, 
+        /*cancelFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_cancel_u64, 
+        /*completeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_complete_u64, 
+        /*freeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_free_u64, 
+        // Async returns always go through the JS-side converter: the
+        // FFI symbol returns the future handle (u64), and the user-level
+        // RustBuffer comes back via the shared `rust_future_complete_*`
+        // export. The bytes the runtime hands back must be deserialized
+        // here using the per-callable return-type converter.
+        /*liftFunc:*/ FfiConverterTypeCuaDriverSession.lift.bind(FfiConverterTypeCuaDriverSession), 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+        /*asyncOpts:*/ asyncOpts_, 
+        /*errorHandler:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError));
+    }
+    catch (__error) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+}
 /**
  * Generated-language host factory for a session-bound action surface.
  *
@@ -566,74 +609,920 @@ const FfiConverterTypeEmbeddedMcpConfiguration = (() => {
                 args: FfiConverterSequenceString.read(from),
                 environment: FfiConverterSequenceTypeEmbeddedEnvironmentVariable.read(from)
             };
-        }
-        write(value, into) {
-            FfiConverterString.write(value.command, into);
-            FfiConverterSequenceString.write(value.args, into);
-            FfiConverterSequenceTypeEmbeddedEnvironmentVariable.write(value.environment, into);
-        }
-        allocationSize(value) {
-            return FfiConverterString.allocationSize(value.command) +
-                FfiConverterSequenceString.allocationSize(value.args) +
-                FfiConverterSequenceTypeEmbeddedEnvironmentVariable.allocationSize(value.environment);
-        }
-    }
-    ;
-    return new FFIConverter();
-})();
-/**
- * Generated factory for {@link EmbeddedDriverConnection} record objects.
- */
-export const EmbeddedDriverConnection = (() => {
-    const defaults = () => ({});
-    const create = (() => {
-        return uniffiCreateRecord(defaults);
-    })();
-    return Object.freeze({
-        create,
-        new: create,
-        defaults: () => Object.freeze(defaults()),
-    });
-})();
-const FfiConverterTypeEmbeddedDriverConnection = (() => {
-    class FFIConverter extends AbstractFfiConverterByteArray {
-        read(from) {
-            return {
-                socketPath: FfiConverterString.read(from),
-                pid: FfiConverterUInt32.read(from),
-                generation: FfiConverterString.read(from),
-                driverVersion: FfiConverterString.read(from),
-                contractVersion: FfiConverterString.read(from),
-                mcpProtocolVersion: FfiConverterString.read(from),
-                mcp: FfiConverterTypeEmbeddedMcpConfiguration.read(from)
+        }
+        write(value, into) {
+            FfiConverterString.write(value.command, into);
+            FfiConverterSequenceString.write(value.args, into);
+            FfiConverterSequenceTypeEmbeddedEnvironmentVariable.write(value.environment, into);
+        }
+        allocationSize(value) {
+            return FfiConverterString.allocationSize(value.command) +
+                FfiConverterSequenceString.allocationSize(value.args) +
+                FfiConverterSequenceTypeEmbeddedEnvironmentVariable.allocationSize(value.environment);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link EmbeddedDriverConnection} record objects.
+ */
+export const EmbeddedDriverConnection = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeEmbeddedDriverConnection = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                socketPath: FfiConverterString.read(from),
+                pid: FfiConverterUInt32.read(from),
+                generation: FfiConverterString.read(from),
+                driverVersion: FfiConverterString.read(from),
+                contractVersion: FfiConverterString.read(from),
+                mcpProtocolVersion: FfiConverterString.read(from),
+                mcp: FfiConverterTypeEmbeddedMcpConfiguration.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterString.write(value.socketPath, into);
+            FfiConverterUInt32.write(value.pid, into);
+            FfiConverterString.write(value.generation, into);
+            FfiConverterString.write(value.driverVersion, into);
+            FfiConverterString.write(value.contractVersion, into);
+            FfiConverterString.write(value.mcpProtocolVersion, into);
+            FfiConverterTypeEmbeddedMcpConfiguration.write(value.mcp, into);
+        }
+        allocationSize(value) {
+            return FfiConverterString.allocationSize(value.socketPath) +
+                FfiConverterUInt32.allocationSize(value.pid) +
+                FfiConverterString.allocationSize(value.generation) +
+                FfiConverterString.allocationSize(value.driverVersion) +
+                FfiConverterString.allocationSize(value.contractVersion) +
+                FfiConverterString.allocationSize(value.mcpProtocolVersion) +
+                FfiConverterTypeEmbeddedMcpConfiguration.allocationSize(value.mcp);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link EmbeddedDriverExit} record objects.
+ */
+export const EmbeddedDriverExit = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeEmbeddedDriverExit = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                generation: FfiConverterString.read(from),
+                code: FfiConverterOptionalInt32.read(from),
+                success: FfiConverterBool.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterString.write(value.generation, into);
+            FfiConverterOptionalInt32.write(value.code, into);
+            FfiConverterBool.write(value.success, into);
+        }
+        allocationSize(value) {
+            return FfiConverterString.allocationSize(value.generation) +
+                FfiConverterOptionalInt32.allocationSize(value.code) +
+                FfiConverterBool.allocationSize(value.success);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+export var EmbeddedPermissionMode;
+(function (EmbeddedPermissionMode) {
+    EmbeddedPermissionMode[EmbeddedPermissionMode["Standard"] = 0] = "Standard";
+    EmbeddedPermissionMode[EmbeddedPermissionMode["Bounded"] = 1] = "Bounded";
+    EmbeddedPermissionMode[EmbeddedPermissionMode["Unrestricted"] = 2] = "Unrestricted";
+})(EmbeddedPermissionMode || (EmbeddedPermissionMode = {}));
+const FfiConverterTypeEmbeddedPermissionMode = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return EmbeddedPermissionMode.Standard;
+                case 2: return EmbeddedPermissionMode.Bounded;
+                case 3: return EmbeddedPermissionMode.Unrestricted;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value) {
+                case EmbeddedPermissionMode.Standard: return ordinalConverter.write(1, into);
+                case EmbeddedPermissionMode.Bounded: return ordinalConverter.write(2, into);
+                case EmbeddedPermissionMode.Unrestricted: return ordinalConverter.write(3, into);
+            }
+        }
+        allocationSize(value) {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link EmbeddedDriverHostOptions} record objects.
+ */
+export const EmbeddedDriverHostOptions = (() => {
+    const defaults = () => ({
+        capabilityManifestPath: undefined,
+        approveCapabilityManifest: false,
+        noOverlay: false
+    });
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeEmbeddedDriverHostOptions = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                binaryPath: FfiConverterString.read(from),
+                hostBundleId: FfiConverterString.read(from),
+                socketPath: FfiConverterOptionalString.read(from),
+                startupTimeoutMs: FfiConverterOptionalUInt64.read(from),
+                shutdownTimeoutMs: FfiConverterOptionalUInt64.read(from),
+                permissionMode: FfiConverterOptionalTypeEmbeddedPermissionMode.read(from),
+                capabilityManifestPath: FfiConverterOptionalString.read(from),
+                approveCapabilityManifest: FfiConverterBool.read(from),
+                sessionPolicyPath: FfiConverterOptionalString.read(from),
+                approveSessionPolicy: FfiConverterBool.read(from),
+                dangerouslyBypassApprovals: FfiConverterBool.read(from),
+                environment: FfiConverterSequenceTypeEmbeddedEnvironmentVariable.read(from),
+                inheritStderr: FfiConverterBool.read(from),
+                noOverlay: FfiConverterBool.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterString.write(value.binaryPath, into);
+            FfiConverterString.write(value.hostBundleId, into);
+            FfiConverterOptionalString.write(value.socketPath, into);
+            FfiConverterOptionalUInt64.write(value.startupTimeoutMs, into);
+            FfiConverterOptionalUInt64.write(value.shutdownTimeoutMs, into);
+            FfiConverterOptionalTypeEmbeddedPermissionMode.write(value.permissionMode, into);
+            FfiConverterOptionalString.write(value.capabilityManifestPath, into);
+            FfiConverterBool.write(value.approveCapabilityManifest, into);
+            FfiConverterOptionalString.write(value.sessionPolicyPath, into);
+            FfiConverterBool.write(value.approveSessionPolicy, into);
+            FfiConverterBool.write(value.dangerouslyBypassApprovals, into);
+            FfiConverterSequenceTypeEmbeddedEnvironmentVariable.write(value.environment, into);
+            FfiConverterBool.write(value.inheritStderr, into);
+            FfiConverterBool.write(value.noOverlay, into);
+        }
+        allocationSize(value) {
+            return FfiConverterString.allocationSize(value.binaryPath) +
+                FfiConverterString.allocationSize(value.hostBundleId) +
+                FfiConverterOptionalString.allocationSize(value.socketPath) +
+                FfiConverterOptionalUInt64.allocationSize(value.startupTimeoutMs) +
+                FfiConverterOptionalUInt64.allocationSize(value.shutdownTimeoutMs) +
+                FfiConverterOptionalTypeEmbeddedPermissionMode.allocationSize(value.permissionMode) +
+                FfiConverterOptionalString.allocationSize(value.capabilityManifestPath) +
+                FfiConverterBool.allocationSize(value.approveCapabilityManifest) +
+                FfiConverterOptionalString.allocationSize(value.sessionPolicyPath) +
+                FfiConverterBool.allocationSize(value.approveSessionPolicy) +
+                FfiConverterBool.allocationSize(value.dangerouslyBypassApprovals) +
+                FfiConverterSequenceTypeEmbeddedEnvironmentVariable.allocationSize(value.environment) +
+                FfiConverterBool.allocationSize(value.inheritStderr) +
+                FfiConverterBool.allocationSize(value.noOverlay);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link ForeignDriverChannelIdentity} record objects.
+ */
+export const ForeignDriverChannelIdentity = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeForeignDriverChannelIdentity = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                authenticatedPrincipal: FfiConverterString.read(from),
+                connectionGeneration: FfiConverterString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterString.write(value.authenticatedPrincipal, into);
+            FfiConverterString.write(value.connectionGeneration, into);
+        }
+        allocationSize(value) {
+            return FfiConverterString.allocationSize(value.authenticatedPrincipal) +
+                FfiConverterString.allocationSize(value.connectionGeneration);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+// Error type: ForeignDriverChannelError
+export var ForeignDriverChannelError_Tags;
+(function (ForeignDriverChannelError_Tags) {
+    ForeignDriverChannelError_Tags["Failed"] = "Failed";
+})(ForeignDriverChannelError_Tags || (ForeignDriverChannelError_Tags = {}));
+export const ForeignDriverChannelError = (() => {
+    class Failed_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "ForeignDriverChannelError";
+        tag = ForeignDriverChannelError_Tags.Failed;
+        inner;
+        constructor(inner) {
+            super("ForeignDriverChannelError", "Failed");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new Failed_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === ForeignDriverChannelError_Tags.Failed;
+        }
+        static hasInner(obj) {
+            return Failed_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    function instanceOf(obj) {
+        return obj[uniffiTypeNameSymbol] === "ForeignDriverChannelError";
+    }
+    return Object.freeze({
+        instanceOf,
+        Failed: Failed_
+    });
+})();
+// FfiConverter for enum ForeignDriverChannelError
+const FfiConverterTypeForeignDriverChannelError = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return new ForeignDriverChannelError.Failed({ reason: FfiConverterString.read(from) });
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value.tag) {
+                case ForeignDriverChannelError_Tags.Failed: {
+                    ordinalConverter.write(1, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.reason, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that ForeignDriverChannelError_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value) {
+            switch (value.tag) {
+                case ForeignDriverChannelError_Tags.Failed: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(1);
+                    size += FfiConverterString.allocationSize(inner.reason);
+                    return size;
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link ForeignDriverChannelCapabilities} record objects.
+ */
+export const ForeignDriverChannelCapabilities = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeForeignDriverChannelCapabilities = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                minimumEnvelopeVersion: FfiConverterUInt32.read(from),
+                maximumEnvelopeVersion: FfiConverterUInt32.read(from),
+                supportsCancellation: FfiConverterBool.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterUInt32.write(value.minimumEnvelopeVersion, into);
+            FfiConverterUInt32.write(value.maximumEnvelopeVersion, into);
+            FfiConverterBool.write(value.supportsCancellation, into);
+        }
+        allocationSize(value) {
+            return FfiConverterUInt32.allocationSize(value.minimumEnvelopeVersion) +
+                FfiConverterUInt32.allocationSize(value.maximumEnvelopeVersion) +
+                FfiConverterBool.allocationSize(value.supportsCancellation);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link ForeignDriverRequestEnvelope} record objects.
+ */
+export const ForeignDriverRequestEnvelope = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeForeignDriverRequestEnvelope = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                envelopeVersion: FfiConverterUInt32.read(from),
+                requestId: FfiConverterString.read(from),
+                operation: FfiConverterString.read(from),
+                name: FfiConverterOptionalString.read(from),
+                argumentsJson: FfiConverterOptionalString.read(from),
+                deadlineUnixMs: FfiConverterUInt64.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterUInt32.write(value.envelopeVersion, into);
+            FfiConverterString.write(value.requestId, into);
+            FfiConverterString.write(value.operation, into);
+            FfiConverterOptionalString.write(value.name, into);
+            FfiConverterOptionalString.write(value.argumentsJson, into);
+            FfiConverterUInt64.write(value.deadlineUnixMs, into);
+        }
+        allocationSize(value) {
+            return FfiConverterUInt32.allocationSize(value.envelopeVersion) +
+                FfiConverterString.allocationSize(value.requestId) +
+                FfiConverterString.allocationSize(value.operation) +
+                FfiConverterOptionalString.allocationSize(value.name) +
+                FfiConverterOptionalString.allocationSize(value.argumentsJson) +
+                FfiConverterUInt64.allocationSize(value.deadlineUnixMs);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link ForeignDriverResponseEnvelope} record objects.
+ */
+export const ForeignDriverResponseEnvelope = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeForeignDriverResponseEnvelope = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                envelopeVersion: FfiConverterUInt32.read(from),
+                requestId: FfiConverterString.read(from),
+                ok: FfiConverterBool.read(from),
+                resultJson: FfiConverterOptionalString.read(from),
+                error: FfiConverterOptionalString.read(from),
+                errorCode: FfiConverterOptionalString.read(from),
+                completionKnown: FfiConverterBool.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterUInt32.write(value.envelopeVersion, into);
+            FfiConverterString.write(value.requestId, into);
+            FfiConverterBool.write(value.ok, into);
+            FfiConverterOptionalString.write(value.resultJson, into);
+            FfiConverterOptionalString.write(value.error, into);
+            FfiConverterOptionalString.write(value.errorCode, into);
+            FfiConverterBool.write(value.completionKnown, into);
+        }
+        allocationSize(value) {
+            return FfiConverterUInt32.allocationSize(value.envelopeVersion) +
+                FfiConverterString.allocationSize(value.requestId) +
+                FfiConverterBool.allocationSize(value.ok) +
+                FfiConverterOptionalString.allocationSize(value.resultJson) +
+                FfiConverterOptionalString.allocationSize(value.error) +
+                FfiConverterOptionalString.allocationSize(value.errorCode) +
+                FfiConverterBool.allocationSize(value.completionKnown);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link TrustedSessionOptions} record objects.
+ */
+export const TrustedSessionOptions = (() => {
+    const defaults = () => ({
+        capabilityManifestPath: undefined,
+    });
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeTrustedSessionOptions = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                publicSession: FfiConverterString.read(from),
+                mode: FfiConverterTypeSessionPermissionMode.read(from),
+                ttlSeconds: FfiConverterUInt64.read(from),
+                idleTtlSeconds: FfiConverterUInt64.read(from),
+                capabilityManifestPath: FfiConverterOptionalString.read(from),
+                boundedManifestPath: FfiConverterOptionalString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterString.write(value.publicSession, into);
+            FfiConverterTypeSessionPermissionMode.write(value.mode, into);
+            FfiConverterUInt64.write(value.ttlSeconds, into);
+            FfiConverterUInt64.write(value.idleTtlSeconds, into);
+            FfiConverterOptionalString.write(value.capabilityManifestPath, into);
+            FfiConverterOptionalString.write(value.boundedManifestPath, into);
+        }
+        allocationSize(value) {
+            return FfiConverterString.allocationSize(value.publicSession) +
+                FfiConverterTypeSessionPermissionMode.allocationSize(value.mode) +
+                FfiConverterUInt64.allocationSize(value.ttlSeconds) +
+                FfiConverterUInt64.allocationSize(value.idleTtlSeconds) +
+                FfiConverterOptionalString.allocationSize(value.capabilityManifestPath) +
+                FfiConverterOptionalString.allocationSize(value.boundedManifestPath);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Trusted host implementation of the existing remote transport contract.
+ * Identity is captured once when each channel is adapted. A bound channel
+ * must retain its parent's authenticated principal and connection generation.
+ */
+export class ForeignDriverEnvelopeChannelImpl extends UniffiAbstractObject {
+    [uniffiTypeNameSymbol] = "ForeignDriverEnvelopeChannelImpl";
+    [destructorGuardSymbol];
+    [pointerLiteralSymbol];
+    // No primary constructor declared for this class.
+    constructor(pointer) {
+        super();
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeForeignDriverEnvelopeChannelImplObjectFactory.bless(pointer);
+    }
+    identity() {
+        return ((__rb) => {
+            try {
+                return FfiConverterTypeForeignDriverChannelIdentity.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeForeignDriverChannelError.lift.bind(FfiConverterTypeForeignDriverChannelError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_method_foreigndriverenvelopechannel_identity(uniffiTypeForeignDriverEnvelopeChannelImplObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    async negotiate(asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_foreigndriverenvelopechannel_negotiate(uniffiTypeForeignDriverEnvelopeChannelImplObjectFactory.clonePointer(this));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_poll_rust_buffer, 
+            /*cancelFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_cancel_rust_buffer, 
+            /*completeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_complete_rust_buffer, 
+            /*freeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_free_rust_buffer, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeForeignDriverChannelCapabilities.lift.bind(FfiConverterTypeForeignDriverChannelCapabilities), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeForeignDriverChannelError.lift.bind(FfiConverterTypeForeignDriverChannelError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    async exchange(request, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_foreigndriverenvelopechannel_exchange(uniffiTypeForeignDriverEnvelopeChannelImplObjectFactory.clonePointer(this), FfiConverterTypeForeignDriverRequestEnvelope.lower(request, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_poll_rust_buffer, 
+            /*cancelFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_cancel_rust_buffer, 
+            /*completeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_complete_rust_buffer, 
+            /*freeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_free_rust_buffer, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeForeignDriverResponseEnvelope.lift.bind(FfiConverterTypeForeignDriverResponseEnvelope), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeForeignDriverChannelError.lift.bind(FfiConverterTypeForeignDriverChannelError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    async bindSession(options, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_foreigndriverenvelopechannel_bind_session(uniffiTypeForeignDriverEnvelopeChannelImplObjectFactory.clonePointer(this), FfiConverterTypeTrustedSessionOptions.lower(options, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_poll_rust_buffer, 
+            /*cancelFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_cancel_rust_buffer, 
+            /*completeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_complete_rust_buffer, 
+            /*freeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_free_rust_buffer, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeForeignDriverBoundChannel.lift.bind(FfiConverterTypeForeignDriverBoundChannel), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeForeignDriverChannelError.lift.bind(FfiConverterTypeForeignDriverChannelError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    async cancel(requestId, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_foreigndriverenvelopechannel_cancel(uniffiTypeForeignDriverEnvelopeChannelImplObjectFactory.clonePointer(this), FfiConverterString.lower(requestId, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_poll_void, 
+            /*cancelFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_cancel_void, 
+            /*completeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_complete_void, 
+            /*freeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_free_void, 
+            /*liftFunc:*/ (_v) => { }, 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeForeignDriverChannelError.lift.bind(FfiConverterTypeForeignDriverChannelError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    async close(asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_foreigndriverenvelopechannel_close(uniffiTypeForeignDriverEnvelopeChannelImplObjectFactory.clonePointer(this));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_poll_void, 
+            /*cancelFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_cancel_void, 
+            /*completeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_complete_void, 
+            /*freeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_free_void, 
+            /*liftFunc:*/ (_v) => { }, 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeForeignDriverChannelError.lift.bind(FfiConverterTypeForeignDriverChannelError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    uniffiDestroy() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeForeignDriverEnvelopeChannelImplObjectFactory.pointer(this);
+            uniffiTypeForeignDriverEnvelopeChannelImplObjectFactory.freePointer(pointer);
+            uniffiTypeForeignDriverEnvelopeChannelImplObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj_) {
+        return uniffiTypeForeignDriverEnvelopeChannelImplObjectFactory.isConcreteType(obj_);
+    }
+}
+const uniffiTypeForeignDriverEnvelopeChannelImplObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry((heldValue) => {
+        uniffiTypeForeignDriverEnvelopeChannelImplObjectFactory.freePointer(heldValue);
+    }) : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(ForeignDriverEnvelopeChannelImpl.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "ForeignDriverEnvelopeChannelImpl";
+            return instance;
+        },
+        bless(p) {
+            const ptr = {
+                p, // make sure this object doesn't get optimized away.
+                markDestroyed: () => undefined,
+            };
+            if (registry) {
+                registry.register(ptr, p, ptr);
+            }
+            return ptr;
+        },
+        unbless(ptr_) {
+            if (registry) {
+                registry.unregister(ptr_);
+            }
+        },
+        pointer(obj_) {
+            if (obj_[destructorGuardSymbol] === undefined) {
+                throw new UniffiInternalError.UnexpectedNullPointer();
+            }
+            return obj_[pointerLiteralSymbol];
+        },
+        clonePointer(obj_) {
+            const pointer = this.pointer(obj_);
+            return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_cua_driver_sdk_fn_clone_foreigndriverenvelopechannel(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        freePointer(pointer) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_cua_driver_sdk_fn_free_foreigndriverenvelopechannel(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj_) {
+            return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "ForeignDriverEnvelopeChannelImpl";
+        },
+    };
+})();
+const FfiConverterTypeForeignDriverEnvelopeChannel = new FfiConverterObjectWithCallbacks(uniffiTypeForeignDriverEnvelopeChannelImplObjectFactory);
+// Add a vtable for the callbacks that go in ForeignDriverEnvelopeChannel.
+// Put the implementation in a struct so we don't pollute the top-level namespace
+const uniffiCallbackInterfaceForeignDriverEnvelopeChannel = {
+    // Create the VTable using a series of closures.
+    // ts automatically converts these into C callback functions.
+    vtable: {
+        identity: (uniffiHandle) => {
+            const uniffiMakeCall = () => {
+                const jsCallback = FfiConverterTypeForeignDriverEnvelopeChannel.lift(uniffiHandle);
+                return jsCallback.identity();
+            };
+            const uniffiResult = UniffiResult.ready();
+            const uniffiHandleSuccess = (obj) => {
+                UniffiResult.writeSuccess(uniffiResult, FfiConverterTypeForeignDriverChannelIdentity.lower(obj, nativeModule().rustbuffer_alloc));
+            };
+            const uniffiHandleError = (code, errBuf) => {
+                UniffiResult.writeError(uniffiResult, code, errBuf);
+            };
+            uniffiTraitInterfaceCallWithError(
+            /*makeCall:*/ uniffiMakeCall, 
+            /*handleSuccess:*/ uniffiHandleSuccess, 
+            /*handleError:*/ uniffiHandleError, 
+            /*isErrorType:*/ ForeignDriverChannelError.instanceOf, 
+            /*lowerError:*/ FfiConverterTypeForeignDriverChannelError.lower.bind(FfiConverterTypeForeignDriverChannelError), 
+            /*lowerString:*/ FfiConverterString.lower.bind(FfiConverterString), 
+            /*alloc:*/ nativeModule().rustbuffer_alloc);
+            return uniffiResult;
+        },
+        negotiate: (uniffiHandle, uniffiFutureCallback, uniffiCallbackData) => {
+            const uniffiMakeCall = async (signal) => {
+                const jsCallback = FfiConverterTypeForeignDriverEnvelopeChannel.lift(uniffiHandle);
+                return await jsCallback.negotiate({ signal });
+            };
+            const uniffiHandleSuccess = (returnValue) => {
+                uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, 
+                /* UniffiForeignFutureResultRustBuffer */ {
+                    return_value: FfiConverterTypeForeignDriverChannelCapabilities.lower(returnValue, nativeModule().rustbuffer_alloc),
+                    call_status: uniffiCaller.createCallStatus()
+                });
+            };
+            const uniffiHandleError = (code, errorBuf) => {
+                uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, 
+                /* UniffiForeignFutureResultRustBuffer */ {
+                    return_value: /*empty*/ new Uint8Array(0),
+                    // TODO create callstatus with error.
+                    call_status: uniffiCaller.createErrorStatus(code, errorBuf),
+                });
+            };
+            const uniffiForeignFuture = uniffiTraitInterfaceCallAsyncWithError(
+            /*makeCall:*/ uniffiMakeCall, 
+            /*handleSuccess:*/ uniffiHandleSuccess, 
+            /*handleError:*/ uniffiHandleError, 
+            /*isErrorType:*/ ForeignDriverChannelError.instanceOf, 
+            /*lowerError:*/ FfiConverterTypeForeignDriverChannelError.lower.bind(FfiConverterTypeForeignDriverChannelError), 
+            /*lowerString:*/ FfiConverterString.lower.bind(FfiConverterString), 
+            /*alloc:*/ nativeModule().rustbuffer_alloc);
+            return uniffiForeignFuture;
+        },
+        exchange: (uniffiHandle, request, uniffiFutureCallback, uniffiCallbackData) => {
+            const uniffiMakeCall = async (signal) => {
+                const jsCallback = FfiConverterTypeForeignDriverEnvelopeChannel.lift(uniffiHandle);
+                return await jsCallback.exchange(FfiConverterTypeForeignDriverRequestEnvelope.lift(request), { signal });
+            };
+            const uniffiHandleSuccess = (returnValue) => {
+                uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, 
+                /* UniffiForeignFutureResultRustBuffer */ {
+                    return_value: FfiConverterTypeForeignDriverResponseEnvelope.lower(returnValue, nativeModule().rustbuffer_alloc),
+                    call_status: uniffiCaller.createCallStatus()
+                });
+            };
+            const uniffiHandleError = (code, errorBuf) => {
+                uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, 
+                /* UniffiForeignFutureResultRustBuffer */ {
+                    return_value: /*empty*/ new Uint8Array(0),
+                    // TODO create callstatus with error.
+                    call_status: uniffiCaller.createErrorStatus(code, errorBuf),
+                });
+            };
+            const uniffiForeignFuture = uniffiTraitInterfaceCallAsyncWithError(
+            /*makeCall:*/ uniffiMakeCall, 
+            /*handleSuccess:*/ uniffiHandleSuccess, 
+            /*handleError:*/ uniffiHandleError, 
+            /*isErrorType:*/ ForeignDriverChannelError.instanceOf, 
+            /*lowerError:*/ FfiConverterTypeForeignDriverChannelError.lower.bind(FfiConverterTypeForeignDriverChannelError), 
+            /*lowerString:*/ FfiConverterString.lower.bind(FfiConverterString), 
+            /*alloc:*/ nativeModule().rustbuffer_alloc);
+            return uniffiForeignFuture;
+        },
+        bind_session: (uniffiHandle, options, uniffiFutureCallback, uniffiCallbackData) => {
+            const uniffiMakeCall = async (signal) => {
+                const jsCallback = FfiConverterTypeForeignDriverEnvelopeChannel.lift(uniffiHandle);
+                return await jsCallback.bindSession(FfiConverterTypeTrustedSessionOptions.lift(options), { signal });
+            };
+            const uniffiHandleSuccess = (returnValue) => {
+                uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, 
+                /* UniffiForeignFutureResultRustBuffer */ {
+                    return_value: FfiConverterTypeForeignDriverBoundChannel.lower(returnValue, nativeModule().rustbuffer_alloc),
+                    call_status: uniffiCaller.createCallStatus()
+                });
+            };
+            const uniffiHandleError = (code, errorBuf) => {
+                uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, 
+                /* UniffiForeignFutureResultRustBuffer */ {
+                    return_value: /*empty*/ new Uint8Array(0),
+                    // TODO create callstatus with error.
+                    call_status: uniffiCaller.createErrorStatus(code, errorBuf),
+                });
+            };
+            const uniffiForeignFuture = uniffiTraitInterfaceCallAsyncWithError(
+            /*makeCall:*/ uniffiMakeCall, 
+            /*handleSuccess:*/ uniffiHandleSuccess, 
+            /*handleError:*/ uniffiHandleError, 
+            /*isErrorType:*/ ForeignDriverChannelError.instanceOf, 
+            /*lowerError:*/ FfiConverterTypeForeignDriverChannelError.lower.bind(FfiConverterTypeForeignDriverChannelError), 
+            /*lowerString:*/ FfiConverterString.lower.bind(FfiConverterString), 
+            /*alloc:*/ nativeModule().rustbuffer_alloc);
+            return uniffiForeignFuture;
+        },
+        cancel: (uniffiHandle, requestId, uniffiFutureCallback, uniffiCallbackData) => {
+            const uniffiMakeCall = async (signal) => {
+                const jsCallback = FfiConverterTypeForeignDriverEnvelopeChannel.lift(uniffiHandle);
+                return await jsCallback.cancel(FfiConverterString.lift(requestId), { signal });
+            };
+            const uniffiHandleSuccess = (returnValue) => {
+                uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, 
+                /* UniffiForeignFutureResultVoid */ {
+                    call_status: uniffiCaller.createCallStatus()
+                });
+            };
+            const uniffiHandleError = (code, errorBuf) => {
+                uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, 
+                /* UniffiForeignFutureResultVoid */ {
+                    // TODO create callstatus with error.
+                    call_status: uniffiCaller.createErrorStatus(code, errorBuf),
+                });
+            };
+            const uniffiForeignFuture = uniffiTraitInterfaceCallAsyncWithError(
+            /*makeCall:*/ uniffiMakeCall, 
+            /*handleSuccess:*/ uniffiHandleSuccess, 
+            /*handleError:*/ uniffiHandleError, 
+            /*isErrorType:*/ ForeignDriverChannelError.instanceOf, 
+            /*lowerError:*/ FfiConverterTypeForeignDriverChannelError.lower.bind(FfiConverterTypeForeignDriverChannelError), 
+            /*lowerString:*/ FfiConverterString.lower.bind(FfiConverterString), 
+            /*alloc:*/ nativeModule().rustbuffer_alloc);
+            return uniffiForeignFuture;
+        },
+        close: (uniffiHandle, uniffiFutureCallback, uniffiCallbackData) => {
+            const uniffiMakeCall = async (signal) => {
+                const jsCallback = FfiConverterTypeForeignDriverEnvelopeChannel.lift(uniffiHandle);
+                return await jsCallback.close({ signal });
+            };
+            const uniffiHandleSuccess = (returnValue) => {
+                uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, 
+                /* UniffiForeignFutureResultVoid */ {
+                    call_status: uniffiCaller.createCallStatus()
+                });
+            };
+            const uniffiHandleError = (code, errorBuf) => {
+                uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, 
+                /* UniffiForeignFutureResultVoid */ {
+                    // TODO create callstatus with error.
+                    call_status: uniffiCaller.createErrorStatus(code, errorBuf),
+                });
             };
+            const uniffiForeignFuture = uniffiTraitInterfaceCallAsyncWithError(
+            /*makeCall:*/ uniffiMakeCall, 
+            /*handleSuccess:*/ uniffiHandleSuccess, 
+            /*handleError:*/ uniffiHandleError, 
+            /*isErrorType:*/ ForeignDriverChannelError.instanceOf, 
+            /*lowerError:*/ FfiConverterTypeForeignDriverChannelError.lower.bind(FfiConverterTypeForeignDriverChannelError), 
+            /*lowerString:*/ FfiConverterString.lower.bind(FfiConverterString), 
+            /*alloc:*/ nativeModule().rustbuffer_alloc);
+            return uniffiForeignFuture;
+        },
+        uniffi_free: (uniffiHandle) => {
+            // this will throw a stale handle error if the handle isn't found.
+            FfiConverterTypeForeignDriverEnvelopeChannel.drop(uniffiHandle);
+        },
+        uniffi_clone: (uniffiHandle) => {
+            return FfiConverterTypeForeignDriverEnvelopeChannel.clone(uniffiHandle);
         }
-        write(value, into) {
-            FfiConverterString.write(value.socketPath, into);
-            FfiConverterUInt32.write(value.pid, into);
-            FfiConverterString.write(value.generation, into);
-            FfiConverterString.write(value.driverVersion, into);
-            FfiConverterString.write(value.contractVersion, into);
-            FfiConverterString.write(value.mcpProtocolVersion, into);
-            FfiConverterTypeEmbeddedMcpConfiguration.write(value.mcp, into);
-        }
-        allocationSize(value) {
-            return FfiConverterString.allocationSize(value.socketPath) +
-                FfiConverterUInt32.allocationSize(value.pid) +
-                FfiConverterString.allocationSize(value.generation) +
-                FfiConverterString.allocationSize(value.driverVersion) +
-                FfiConverterString.allocationSize(value.contractVersion) +
-                FfiConverterString.allocationSize(value.mcpProtocolVersion) +
-                FfiConverterTypeEmbeddedMcpConfiguration.allocationSize(value.mcp);
-        }
-    }
-    ;
-    return new FFIConverter();
-})();
+    },
+    register: () => {
+        nativeModule().uniffi_cua_driver_sdk_fn_init_callback_vtable_foreigndriverenvelopechannel(uniffiCallbackInterfaceForeignDriverEnvelopeChannel.vtable);
+    },
+};
 /**
- * Generated factory for {@link EmbeddedDriverExit} record objects.
+ * Generated factory for {@link ForeignDriverBoundChannel} record objects.
  */
-export const EmbeddedDriverExit = (() => {
+export const ForeignDriverBoundChannel = (() => {
     const defaults = () => ({});
     const create = (() => {
         return uniffiCreateRecord(defaults);
@@ -644,128 +1533,18 @@ export const EmbeddedDriverExit = (() => {
         defaults: () => Object.freeze(defaults()),
     });
 })();
-const FfiConverterTypeEmbeddedDriverExit = (() => {
-    class FFIConverter extends AbstractFfiConverterByteArray {
-        read(from) {
-            return {
-                generation: FfiConverterString.read(from),
-                code: FfiConverterOptionalInt32.read(from),
-                success: FfiConverterBool.read(from)
-            };
-        }
-        write(value, into) {
-            FfiConverterString.write(value.generation, into);
-            FfiConverterOptionalInt32.write(value.code, into);
-            FfiConverterBool.write(value.success, into);
-        }
-        allocationSize(value) {
-            return FfiConverterString.allocationSize(value.generation) +
-                FfiConverterOptionalInt32.allocationSize(value.code) +
-                FfiConverterBool.allocationSize(value.success);
-        }
-    }
-    ;
-    return new FFIConverter();
-})();
-export var EmbeddedPermissionMode;
-(function (EmbeddedPermissionMode) {
-    EmbeddedPermissionMode[EmbeddedPermissionMode["Standard"] = 0] = "Standard";
-    EmbeddedPermissionMode[EmbeddedPermissionMode["Bounded"] = 1] = "Bounded";
-    EmbeddedPermissionMode[EmbeddedPermissionMode["Unrestricted"] = 2] = "Unrestricted";
-})(EmbeddedPermissionMode || (EmbeddedPermissionMode = {}));
-const FfiConverterTypeEmbeddedPermissionMode = (() => {
-    const ordinalConverter = FfiConverterInt32;
-    class FFIConverter extends AbstractFfiConverterByteArray {
-        read(from) {
-            switch (ordinalConverter.read(from)) {
-                case 1: return EmbeddedPermissionMode.Standard;
-                case 2: return EmbeddedPermissionMode.Bounded;
-                case 3: return EmbeddedPermissionMode.Unrestricted;
-                default: throw new UniffiInternalError.UnexpectedEnumCase();
-            }
-        }
-        write(value, into) {
-            switch (value) {
-                case EmbeddedPermissionMode.Standard: return ordinalConverter.write(1, into);
-                case EmbeddedPermissionMode.Bounded: return ordinalConverter.write(2, into);
-                case EmbeddedPermissionMode.Unrestricted: return ordinalConverter.write(3, into);
-            }
-        }
-        allocationSize(value) {
-            return ordinalConverter.allocationSize(0);
-        }
-    }
-    return new FFIConverter();
-})();
-/**
- * Generated factory for {@link EmbeddedDriverHostOptions} record objects.
- */
-export const EmbeddedDriverHostOptions = (() => {
-    const defaults = () => ({
-        capabilityManifestPath: undefined,
-        approveCapabilityManifest: false,
-        noOverlay: false
-    });
-    const create = (() => {
-        return uniffiCreateRecord(defaults);
-    })();
-    return Object.freeze({
-        create,
-        new: create,
-        defaults: () => Object.freeze(defaults()),
-    });
-})();
-const FfiConverterTypeEmbeddedDriverHostOptions = (() => {
+const FfiConverterTypeForeignDriverBoundChannel = (() => {
     class FFIConverter extends AbstractFfiConverterByteArray {
         read(from) {
             return {
-                binaryPath: FfiConverterString.read(from),
-                hostBundleId: FfiConverterString.read(from),
-                socketPath: FfiConverterOptionalString.read(from),
-                startupTimeoutMs: FfiConverterOptionalUInt64.read(from),
-                shutdownTimeoutMs: FfiConverterOptionalUInt64.read(from),
-                permissionMode: FfiConverterOptionalTypeEmbeddedPermissionMode.read(from),
-                capabilityManifestPath: FfiConverterOptionalString.read(from),
-                approveCapabilityManifest: FfiConverterBool.read(from),
-                sessionPolicyPath: FfiConverterOptionalString.read(from),
-                approveSessionPolicy: FfiConverterBool.read(from),
-                dangerouslyBypassApprovals: FfiConverterBool.read(from),
-                environment: FfiConverterSequenceTypeEmbeddedEnvironmentVariable.read(from),
-                inheritStderr: FfiConverterBool.read(from),
-                noOverlay: FfiConverterBool.read(from)
+                channel: FfiConverterTypeForeignDriverEnvelopeChannel.read(from)
             };
         }
         write(value, into) {
-            FfiConverterString.write(value.binaryPath, into);
-            FfiConverterString.write(value.hostBundleId, into);
-            FfiConverterOptionalString.write(value.socketPath, into);
-            FfiConverterOptionalUInt64.write(value.startupTimeoutMs, into);
-            FfiConverterOptionalUInt64.write(value.shutdownTimeoutMs, into);
-            FfiConverterOptionalTypeEmbeddedPermissionMode.write(value.permissionMode, into);
-            FfiConverterOptionalString.write(value.capabilityManifestPath, into);
-            FfiConverterBool.write(value.approveCapabilityManifest, into);
-            FfiConverterOptionalString.write(value.sessionPolicyPath, into);
-            FfiConverterBool.write(value.approveSessionPolicy, into);
-            FfiConverterBool.write(value.dangerouslyBypassApprovals, into);
-            FfiConverterSequenceTypeEmbeddedEnvironmentVariable.write(value.environment, into);
-            FfiConverterBool.write(value.inheritStderr, into);
-            FfiConverterBool.write(value.noOverlay, into);
+            FfiConverterTypeForeignDriverEnvelopeChannel.write(value.channel, into);
         }
         allocationSize(value) {
-            return FfiConverterString.allocationSize(value.binaryPath) +
-                FfiConverterString.allocationSize(value.hostBundleId) +
-                FfiConverterOptionalString.allocationSize(value.socketPath) +
-                FfiConverterOptionalUInt64.allocationSize(value.startupTimeoutMs) +
-                FfiConverterOptionalUInt64.allocationSize(value.shutdownTimeoutMs) +
-                FfiConverterOptionalTypeEmbeddedPermissionMode.allocationSize(value.permissionMode) +
-                FfiConverterOptionalString.allocationSize(value.capabilityManifestPath) +
-                FfiConverterBool.allocationSize(value.approveCapabilityManifest) +
-                FfiConverterOptionalString.allocationSize(value.sessionPolicyPath) +
-                FfiConverterBool.allocationSize(value.approveSessionPolicy) +
-                FfiConverterBool.allocationSize(value.dangerouslyBypassApprovals) +
-                FfiConverterSequenceTypeEmbeddedEnvironmentVariable.allocationSize(value.environment) +
-                FfiConverterBool.allocationSize(value.inheritStderr) +
-                FfiConverterBool.allocationSize(value.noOverlay);
+            return FfiConverterTypeForeignDriverEnvelopeChannel.allocationSize(value.channel);
         }
     }
     ;
@@ -943,54 +1722,6 @@ const FfiConverterTypeToolResult = (() => {
     ;
     return new FFIConverter();
 })();
-/**
- * Generated factory for {@link TrustedSessionOptions} record objects.
- */
-export const TrustedSessionOptions = (() => {
-    const defaults = () => ({
-        capabilityManifestPath: undefined,
-    });
-    const create = (() => {
-        return uniffiCreateRecord(defaults);
-    })();
-    return Object.freeze({
-        create,
-        new: create,
-        defaults: () => Object.freeze(defaults()),
-    });
-})();
-const FfiConverterTypeTrustedSessionOptions = (() => {
-    class FFIConverter extends AbstractFfiConverterByteArray {
-        read(from) {
-            return {
-                publicSession: FfiConverterString.read(from),
-                mode: FfiConverterTypeSessionPermissionMode.read(from),
-                ttlSeconds: FfiConverterUInt64.read(from),
-                idleTtlSeconds: FfiConverterUInt64.read(from),
-                capabilityManifestPath: FfiConverterOptionalString.read(from),
-                boundedManifestPath: FfiConverterOptionalString.read(from)
-            };
-        }
-        write(value, into) {
-            FfiConverterString.write(value.publicSession, into);
-            FfiConverterTypeSessionPermissionMode.write(value.mode, into);
-            FfiConverterUInt64.write(value.ttlSeconds, into);
-            FfiConverterUInt64.write(value.idleTtlSeconds, into);
-            FfiConverterOptionalString.write(value.capabilityManifestPath, into);
-            FfiConverterOptionalString.write(value.boundedManifestPath, into);
-        }
-        allocationSize(value) {
-            return FfiConverterString.allocationSize(value.publicSession) +
-                FfiConverterTypeSessionPermissionMode.allocationSize(value.mode) +
-                FfiConverterUInt64.allocationSize(value.ttlSeconds) +
-                FfiConverterUInt64.allocationSize(value.idleTtlSeconds) +
-                FfiConverterOptionalString.allocationSize(value.capabilityManifestPath) +
-                FfiConverterOptionalString.allocationSize(value.boundedManifestPath);
-        }
-    }
-    ;
-    return new FFIConverter();
-})();
 export var ActionCompletion;
 (function (ActionCompletion) {
     ActionCompletion[ActionCompletion["NotStarted"] = 0] = "NotStarted";
@@ -4545,6 +5276,12 @@ function uniffiEnsureInitialized() {
     if (bindingsContractVersion !== scaffoldingContractVersion) {
         throw new UniffiInternalError.ContractVersionMismatch(scaffoldingContractVersion, bindingsContractVersion);
     }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_func_connect_remote_channel() !== 54784) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_func_connect_remote_channel");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_func_create_remote_trusted_session() !== 53066) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_func_create_remote_trusted_session");
+    }
     if (nativeModule().uniffi_cua_driver_sdk_checksum_func_create_trusted_session() !== 50573) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_func_create_trusted_session");
     }
@@ -4812,6 +5549,25 @@ function uniffiEnsureInitialized() {
     if (nativeModule().uniffi_cua_driver_sdk_checksum_method_embeddedcuadriverhost_wait_for_exit() !== 21124) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_embeddedcuadriverhost_wait_for_exit");
     }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_foreigndriverenvelopechannel_identity() !== 13418) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_foreigndriverenvelopechannel_identity");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_foreigndriverenvelopechannel_negotiate() !== 29939) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_foreigndriverenvelopechannel_negotiate");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_foreigndriverenvelopechannel_exchange() !== 707) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_foreigndriverenvelopechannel_exchange");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_foreigndriverenvelopechannel_bind_session() !== 6555) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_foreigndriverenvelopechannel_bind_session");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_foreigndriverenvelopechannel_cancel() !== 60148) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_foreigndriverenvelopechannel_cancel");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_foreigndriverenvelopechannel_close() !== 42601) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_foreigndriverenvelopechannel_close");
+    }
+    uniffiCallbackInterfaceForeignDriverEnvelopeChannel.register();
     uniffiCallbackInterfaceDriverActivityObserver.register();
     uniffiCallbackInterfaceDriverAuthorizationHost.register();
 }
@@ -4843,6 +5599,13 @@ export default Object.freeze({
         FfiConverterTypeEmbeddedEnvironmentVariable,
         FfiConverterTypeEmbeddedMcpConfiguration,
         FfiConverterTypeEmbeddedPermissionMode,
+        FfiConverterTypeForeignDriverBoundChannel,
+        FfiConverterTypeForeignDriverChannelCapabilities,
+        FfiConverterTypeForeignDriverChannelError,
+        FfiConverterTypeForeignDriverChannelIdentity,
+        FfiConverterTypeForeignDriverEnvelopeChannel,
+        FfiConverterTypeForeignDriverRequestEnvelope,
+        FfiConverterTypeForeignDriverResponseEnvelope,
         FfiConverterTypeImageContent,
         FfiConverterTypeMacOsPermissionStatus,
         FfiConverterTypePrivateWorkerOptions,