@secure-exec/core 0.2.1-rc.1 → 0.3.0-rc.1

package/dist/generated-protocol.js

@@ -0,0 +1,2887 @@
+// @generated - run pnpm --dir packages/build-tools build:protocol
+import * as bare from "@rivetkit/bare-ts";
+const DEFAULT_CONFIG = /* @__PURE__ */ bare.Config({});
+export function readJsonUtf8(bc) {
+    return bare.readString(bc);
+}
+export function writeJsonUtf8(bc, x) {
+    bare.writeString(bc, x);
+}
+export function readProtocolSchema(bc) {
+    return {
+        name: bare.readString(bc),
+        version: bare.readU16(bc),
+    };
+}
+export function writeProtocolSchema(bc, x) {
+    bare.writeString(bc, x.name);
+    bare.writeU16(bc, x.version);
+}
+export function readRequestId(bc) {
+    return bare.readI64(bc);
+}
+export function writeRequestId(bc, x) {
+    bare.writeI64(bc, x);
+}
+export function readExtEnvelope(bc) {
+    return {
+        namespace: bare.readString(bc),
+        payload: bare.readData(bc),
+    };
+}
+export function writeExtEnvelope(bc, x) {
+    bare.writeString(bc, x.namespace);
+    bare.writeData(bc, x.payload);
+}
+export function readConnectionOwnership(bc) {
+    return {
+        connectionId: bare.readString(bc),
+    };
+}
+export function writeConnectionOwnership(bc, x) {
+    bare.writeString(bc, x.connectionId);
+}
+export function readSessionOwnership(bc) {
+    return {
+        connectionId: bare.readString(bc),
+        sessionId: bare.readString(bc),
+    };
+}
+export function writeSessionOwnership(bc, x) {
+    bare.writeString(bc, x.connectionId);
+    bare.writeString(bc, x.sessionId);
+}
+export function readVmOwnership(bc) {
+    return {
+        connectionId: bare.readString(bc),
+        sessionId: bare.readString(bc),
+        vmId: bare.readString(bc),
+    };
+}
+export function writeVmOwnership(bc, x) {
+    bare.writeString(bc, x.connectionId);
+    bare.writeString(bc, x.sessionId);
+    bare.writeString(bc, x.vmId);
+}
+export function readOwnershipScope(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return { tag: "ConnectionOwnership", val: readConnectionOwnership(bc) };
+        case 1:
+            return { tag: "SessionOwnership", val: readSessionOwnership(bc) };
+        case 2:
+            return { tag: "VmOwnership", val: readVmOwnership(bc) };
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeOwnershipScope(bc, x) {
+    switch (x.tag) {
+        case "ConnectionOwnership": {
+            bare.writeU8(bc, 0);
+            writeConnectionOwnership(bc, x.val);
+            break;
+        }
+        case "SessionOwnership": {
+            bare.writeU8(bc, 1);
+            writeSessionOwnership(bc, x.val);
+            break;
+        }
+        case "VmOwnership": {
+            bare.writeU8(bc, 2);
+            writeVmOwnership(bc, x.val);
+            break;
+        }
+    }
+}
+export function readAuthenticateRequest(bc) {
+    return {
+        clientName: bare.readString(bc),
+        authToken: bare.readString(bc),
+        protocolVersion: bare.readU16(bc),
+        bridgeVersion: bare.readU32(bc),
+    };
+}
+export function writeAuthenticateRequest(bc, x) {
+    bare.writeString(bc, x.clientName);
+    bare.writeString(bc, x.authToken);
+    bare.writeU16(bc, x.protocolVersion);
+    bare.writeU32(bc, x.bridgeVersion);
+}
+function read0(bc) {
+    return bare.readBool(bc) ? bare.readString(bc) : null;
+}
+function write0(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        bare.writeString(bc, x);
+    }
+}
+export function readSidecarPlacementShared(bc) {
+    return {
+        pool: read0(bc),
+    };
+}
+export function writeSidecarPlacementShared(bc, x) {
+    write0(bc, x.pool);
+}
+export function readSidecarPlacementExplicit(bc) {
+    return {
+        sidecarId: bare.readString(bc),
+    };
+}
+export function writeSidecarPlacementExplicit(bc, x) {
+    bare.writeString(bc, x.sidecarId);
+}
+export function readSidecarPlacement(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return { tag: "SidecarPlacementShared", val: readSidecarPlacementShared(bc) };
+        case 1:
+            return { tag: "SidecarPlacementExplicit", val: readSidecarPlacementExplicit(bc) };
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeSidecarPlacement(bc, x) {
+    switch (x.tag) {
+        case "SidecarPlacementShared": {
+            bare.writeU8(bc, 0);
+            writeSidecarPlacementShared(bc, x.val);
+            break;
+        }
+        case "SidecarPlacementExplicit": {
+            bare.writeU8(bc, 1);
+            writeSidecarPlacementExplicit(bc, x.val);
+            break;
+        }
+    }
+}
+function read1(bc) {
+    const len = bare.readUintSafe(bc);
+    const result = new Map();
+    for (let i = 0; i < len; i++) {
+        const offset = bc.offset;
+        const key = bare.readString(bc);
+        if (result.has(key)) {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "duplicated key");
+        }
+        result.set(key, bare.readString(bc));
+    }
+    return result;
+}
+function write1(bc, x) {
+    bare.writeUintSafe(bc, x.size);
+    for (const kv of x) {
+        bare.writeString(bc, kv[0]);
+        bare.writeString(bc, kv[1]);
+    }
+}
+export function readOpenSessionRequest(bc) {
+    return {
+        placement: readSidecarPlacement(bc),
+        metadata: read1(bc),
+    };
+}
+export function writeOpenSessionRequest(bc, x) {
+    writeSidecarPlacement(bc, x.placement);
+    write1(bc, x.metadata);
+}
+export var GuestRuntimeKind;
+(function (GuestRuntimeKind) {
+    GuestRuntimeKind["JavaScript"] = "JavaScript";
+    GuestRuntimeKind["Python"] = "Python";
+    GuestRuntimeKind["WebAssembly"] = "WebAssembly";
+})(GuestRuntimeKind || (GuestRuntimeKind = {}));
+export function readGuestRuntimeKind(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return GuestRuntimeKind.JavaScript;
+        case 1:
+            return GuestRuntimeKind.Python;
+        case 2:
+            return GuestRuntimeKind.WebAssembly;
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeGuestRuntimeKind(bc, x) {
+    switch (x) {
+        case GuestRuntimeKind.JavaScript: {
+            bare.writeU8(bc, 0);
+            break;
+        }
+        case GuestRuntimeKind.Python: {
+            bare.writeU8(bc, 1);
+            break;
+        }
+        case GuestRuntimeKind.WebAssembly: {
+            bare.writeU8(bc, 2);
+            break;
+        }
+    }
+}
+export var RootFilesystemMode;
+(function (RootFilesystemMode) {
+    RootFilesystemMode["Ephemeral"] = "Ephemeral";
+    RootFilesystemMode["ReadOnly"] = "ReadOnly";
+})(RootFilesystemMode || (RootFilesystemMode = {}));
+export function readRootFilesystemMode(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return RootFilesystemMode.Ephemeral;
+        case 1:
+            return RootFilesystemMode.ReadOnly;
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeRootFilesystemMode(bc, x) {
+    switch (x) {
+        case RootFilesystemMode.Ephemeral: {
+            bare.writeU8(bc, 0);
+            break;
+        }
+        case RootFilesystemMode.ReadOnly: {
+            bare.writeU8(bc, 1);
+            break;
+        }
+    }
+}
+export var RootFilesystemEntryKind;
+(function (RootFilesystemEntryKind) {
+    RootFilesystemEntryKind["File"] = "File";
+    RootFilesystemEntryKind["Directory"] = "Directory";
+    RootFilesystemEntryKind["Symlink"] = "Symlink";
+})(RootFilesystemEntryKind || (RootFilesystemEntryKind = {}));
+export function readRootFilesystemEntryKind(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return RootFilesystemEntryKind.File;
+        case 1:
+            return RootFilesystemEntryKind.Directory;
+        case 2:
+            return RootFilesystemEntryKind.Symlink;
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeRootFilesystemEntryKind(bc, x) {
+    switch (x) {
+        case RootFilesystemEntryKind.File: {
+            bare.writeU8(bc, 0);
+            break;
+        }
+        case RootFilesystemEntryKind.Directory: {
+            bare.writeU8(bc, 1);
+            break;
+        }
+        case RootFilesystemEntryKind.Symlink: {
+            bare.writeU8(bc, 2);
+            break;
+        }
+    }
+}
+export var RootFilesystemEntryEncoding;
+(function (RootFilesystemEntryEncoding) {
+    RootFilesystemEntryEncoding["UtF8"] = "UtF8";
+    RootFilesystemEntryEncoding["BasE64"] = "BasE64";
+})(RootFilesystemEntryEncoding || (RootFilesystemEntryEncoding = {}));
+export function readRootFilesystemEntryEncoding(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return RootFilesystemEntryEncoding.UtF8;
+        case 1:
+            return RootFilesystemEntryEncoding.BasE64;
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeRootFilesystemEntryEncoding(bc, x) {
+    switch (x) {
+        case RootFilesystemEntryEncoding.UtF8: {
+            bare.writeU8(bc, 0);
+            break;
+        }
+        case RootFilesystemEntryEncoding.BasE64: {
+            bare.writeU8(bc, 1);
+            break;
+        }
+    }
+}
+function read2(bc) {
+    return bare.readBool(bc) ? bare.readU32(bc) : null;
+}
+function write2(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        bare.writeU32(bc, x);
+    }
+}
+function read3(bc) {
+    return bare.readBool(bc) ? readRootFilesystemEntryEncoding(bc) : null;
+}
+function write3(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        writeRootFilesystemEntryEncoding(bc, x);
+    }
+}
+export function readRootFilesystemEntry(bc) {
+    return {
+        path: bare.readString(bc),
+        kind: readRootFilesystemEntryKind(bc),
+        mode: read2(bc),
+        uid: read2(bc),
+        gid: read2(bc),
+        content: read0(bc),
+        encoding: read3(bc),
+        target: read0(bc),
+        executable: bare.readBool(bc),
+    };
+}
+export function writeRootFilesystemEntry(bc, x) {
+    bare.writeString(bc, x.path);
+    writeRootFilesystemEntryKind(bc, x.kind);
+    write2(bc, x.mode);
+    write2(bc, x.uid);
+    write2(bc, x.gid);
+    write0(bc, x.content);
+    write3(bc, x.encoding);
+    write0(bc, x.target);
+    bare.writeBool(bc, x.executable);
+}
+function read4(bc) {
+    const len = bare.readUintSafe(bc);
+    if (len === 0) {
+        return [];
+    }
+    const result = [readRootFilesystemEntry(bc)];
+    for (let i = 1; i < len; i++) {
+        result[i] = readRootFilesystemEntry(bc);
+    }
+    return result;
+}
+function write4(bc, x) {
+    bare.writeUintSafe(bc, x.length);
+    for (let i = 0; i < x.length; i++) {
+        writeRootFilesystemEntry(bc, x[i]);
+    }
+}
+export function readSnapshotRootFilesystemLower(bc) {
+    return {
+        entries: read4(bc),
+    };
+}
+export function writeSnapshotRootFilesystemLower(bc, x) {
+    write4(bc, x.entries);
+}
+export function readRootFilesystemLowerDescriptor(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return { tag: "SnapshotRootFilesystemLower", val: readSnapshotRootFilesystemLower(bc) };
+        case 1:
+            return { tag: "BundledBaseFilesystemLower", val: null };
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeRootFilesystemLowerDescriptor(bc, x) {
+    switch (x.tag) {
+        case "SnapshotRootFilesystemLower": {
+            bare.writeU8(bc, 0);
+            writeSnapshotRootFilesystemLower(bc, x.val);
+            break;
+        }
+        case "BundledBaseFilesystemLower": {
+            bare.writeU8(bc, 1);
+            break;
+        }
+    }
+}
+function read5(bc) {
+    const len = bare.readUintSafe(bc);
+    if (len === 0) {
+        return [];
+    }
+    const result = [readRootFilesystemLowerDescriptor(bc)];
+    for (let i = 1; i < len; i++) {
+        result[i] = readRootFilesystemLowerDescriptor(bc);
+    }
+    return result;
+}
+function write5(bc, x) {
+    bare.writeUintSafe(bc, x.length);
+    for (let i = 0; i < x.length; i++) {
+        writeRootFilesystemLowerDescriptor(bc, x[i]);
+    }
+}
+export function readRootFilesystemDescriptor(bc) {
+    return {
+        mode: readRootFilesystemMode(bc),
+        disableDefaultBaseLayer: bare.readBool(bc),
+        lowers: read5(bc),
+        bootstrapEntries: read4(bc),
+    };
+}
+export function writeRootFilesystemDescriptor(bc, x) {
+    writeRootFilesystemMode(bc, x.mode);
+    bare.writeBool(bc, x.disableDefaultBaseLayer);
+    write5(bc, x.lowers);
+    write4(bc, x.bootstrapEntries);
+}
+export function encodeRootFilesystemDescriptor(x, config) {
+    const fullConfig = config != null ? bare.Config(config) : DEFAULT_CONFIG;
+    const bc = new bare.ByteCursor(new Uint8Array(fullConfig.initialBufferLength), fullConfig);
+    writeRootFilesystemDescriptor(bc, x);
+    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+export function decodeRootFilesystemDescriptor(bytes) {
+    const bc = new bare.ByteCursor(bytes, DEFAULT_CONFIG);
+    const result = readRootFilesystemDescriptor(bc);
+    if (bc.offset < bc.view.byteLength) {
+        throw new bare.BareError(bc.offset, "remaining bytes");
+    }
+    return result;
+}
+export var PermissionMode;
+(function (PermissionMode) {
+    PermissionMode["Allow"] = "Allow";
+    PermissionMode["Ask"] = "Ask";
+    PermissionMode["Deny"] = "Deny";
+})(PermissionMode || (PermissionMode = {}));
+export function readPermissionMode(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return PermissionMode.Allow;
+        case 1:
+            return PermissionMode.Ask;
+        case 2:
+            return PermissionMode.Deny;
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writePermissionMode(bc, x) {
+    switch (x) {
+        case PermissionMode.Allow: {
+            bare.writeU8(bc, 0);
+            break;
+        }
+        case PermissionMode.Ask: {
+            bare.writeU8(bc, 1);
+            break;
+        }
+        case PermissionMode.Deny: {
+            bare.writeU8(bc, 2);
+            break;
+        }
+    }
+}
+function read6(bc) {
+    const len = bare.readUintSafe(bc);
+    if (len === 0) {
+        return [];
+    }
+    const result = [bare.readString(bc)];
+    for (let i = 1; i < len; i++) {
+        result[i] = bare.readString(bc);
+    }
+    return result;
+}
+function write6(bc, x) {
+    bare.writeUintSafe(bc, x.length);
+    for (let i = 0; i < x.length; i++) {
+        bare.writeString(bc, x[i]);
+    }
+}
+export function readFsPermissionRule(bc) {
+    return {
+        mode: readPermissionMode(bc),
+        operations: read6(bc),
+        paths: read6(bc),
+    };
+}
+export function writeFsPermissionRule(bc, x) {
+    writePermissionMode(bc, x.mode);
+    write6(bc, x.operations);
+    write6(bc, x.paths);
+}
+function read7(bc) {
+    return bare.readBool(bc) ? readPermissionMode(bc) : null;
+}
+function write7(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        writePermissionMode(bc, x);
+    }
+}
+function read8(bc) {
+    const len = bare.readUintSafe(bc);
+    if (len === 0) {
+        return [];
+    }
+    const result = [readFsPermissionRule(bc)];
+    for (let i = 1; i < len; i++) {
+        result[i] = readFsPermissionRule(bc);
+    }
+    return result;
+}
+function write8(bc, x) {
+    bare.writeUintSafe(bc, x.length);
+    for (let i = 0; i < x.length; i++) {
+        writeFsPermissionRule(bc, x[i]);
+    }
+}
+export function readFsPermissionRuleSet(bc) {
+    return {
+        default: read7(bc),
+        rules: read8(bc),
+    };
+}
+export function writeFsPermissionRuleSet(bc, x) {
+    write7(bc, x.default);
+    write8(bc, x.rules);
+}
+export function readFsPermissionScope(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return { tag: "PermissionMode", val: readPermissionMode(bc) };
+        case 1:
+            return { tag: "FsPermissionRuleSet", val: readFsPermissionRuleSet(bc) };
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeFsPermissionScope(bc, x) {
+    switch (x.tag) {
+        case "PermissionMode": {
+            bare.writeU8(bc, 0);
+            writePermissionMode(bc, x.val);
+            break;
+        }
+        case "FsPermissionRuleSet": {
+            bare.writeU8(bc, 1);
+            writeFsPermissionRuleSet(bc, x.val);
+            break;
+        }
+    }
+}
+export function readPatternPermissionRule(bc) {
+    return {
+        mode: readPermissionMode(bc),
+        operations: read6(bc),
+        patterns: read6(bc),
+    };
+}
+export function writePatternPermissionRule(bc, x) {
+    writePermissionMode(bc, x.mode);
+    write6(bc, x.operations);
+    write6(bc, x.patterns);
+}
+function read9(bc) {
+    const len = bare.readUintSafe(bc);
+    if (len === 0) {
+        return [];
+    }
+    const result = [readPatternPermissionRule(bc)];
+    for (let i = 1; i < len; i++) {
+        result[i] = readPatternPermissionRule(bc);
+    }
+    return result;
+}
+function write9(bc, x) {
+    bare.writeUintSafe(bc, x.length);
+    for (let i = 0; i < x.length; i++) {
+        writePatternPermissionRule(bc, x[i]);
+    }
+}
+export function readPatternPermissionRuleSet(bc) {
+    return {
+        default: read7(bc),
+        rules: read9(bc),
+    };
+}
+export function writePatternPermissionRuleSet(bc, x) {
+    write7(bc, x.default);
+    write9(bc, x.rules);
+}
+export function readPatternPermissionScope(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return { tag: "PermissionMode", val: readPermissionMode(bc) };
+        case 1:
+            return { tag: "PatternPermissionRuleSet", val: readPatternPermissionRuleSet(bc) };
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writePatternPermissionScope(bc, x) {
+    switch (x.tag) {
+        case "PermissionMode": {
+            bare.writeU8(bc, 0);
+            writePermissionMode(bc, x.val);
+            break;
+        }
+        case "PatternPermissionRuleSet": {
+            bare.writeU8(bc, 1);
+            writePatternPermissionRuleSet(bc, x.val);
+            break;
+        }
+    }
+}
+function read10(bc) {
+    return bare.readBool(bc) ? readFsPermissionScope(bc) : null;
+}
+function write10(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        writeFsPermissionScope(bc, x);
+    }
+}
+function read11(bc) {
+    return bare.readBool(bc) ? readPatternPermissionScope(bc) : null;
+}
+function write11(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        writePatternPermissionScope(bc, x);
+    }
+}
+export function readPermissionsPolicy(bc) {
+    return {
+        fs: read10(bc),
+        network: read11(bc),
+        childProcess: read11(bc),
+        process: read11(bc),
+        env: read11(bc),
+        tool: read11(bc),
+    };
+}
+export function writePermissionsPolicy(bc, x) {
+    write10(bc, x.fs);
+    write11(bc, x.network);
+    write11(bc, x.childProcess);
+    write11(bc, x.process);
+    write11(bc, x.env);
+    write11(bc, x.tool);
+}
+export function readCreateVmRequest(bc) {
+    return {
+        runtime: readGuestRuntimeKind(bc),
+        config: readJsonUtf8(bc),
+    };
+}
+export function writeCreateVmRequest(bc, x) {
+    writeGuestRuntimeKind(bc, x.runtime);
+    writeJsonUtf8(bc, x.config);
+}
+export var DisposeReason;
+(function (DisposeReason) {
+    DisposeReason["Requested"] = "Requested";
+    DisposeReason["ConnectionClosed"] = "ConnectionClosed";
+    DisposeReason["HostShutdown"] = "HostShutdown";
+})(DisposeReason || (DisposeReason = {}));
+export function readDisposeReason(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return DisposeReason.Requested;
+        case 1:
+            return DisposeReason.ConnectionClosed;
+        case 2:
+            return DisposeReason.HostShutdown;
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeDisposeReason(bc, x) {
+    switch (x) {
+        case DisposeReason.Requested: {
+            bare.writeU8(bc, 0);
+            break;
+        }
+        case DisposeReason.ConnectionClosed: {
+            bare.writeU8(bc, 1);
+            break;
+        }
+        case DisposeReason.HostShutdown: {
+            bare.writeU8(bc, 2);
+            break;
+        }
+    }
+}
+export function readDisposeVmRequest(bc) {
+    return {
+        reason: readDisposeReason(bc),
+    };
+}
+export function writeDisposeVmRequest(bc, x) {
+    writeDisposeReason(bc, x.reason);
+}
+export function readBootstrapRootFilesystemRequest(bc) {
+    return {
+        entries: read4(bc),
+    };
+}
+export function writeBootstrapRootFilesystemRequest(bc, x) {
+    write4(bc, x.entries);
+}
+export function readMountPluginDescriptor(bc) {
+    return {
+        id: bare.readString(bc),
+        config: readJsonUtf8(bc),
+    };
+}
+export function writeMountPluginDescriptor(bc, x) {
+    bare.writeString(bc, x.id);
+    writeJsonUtf8(bc, x.config);
+}
+export function readMountDescriptor(bc) {
+    return {
+        guestPath: bare.readString(bc),
+        readOnly: bare.readBool(bc),
+        plugin: readMountPluginDescriptor(bc),
+    };
+}
+export function writeMountDescriptor(bc, x) {
+    bare.writeString(bc, x.guestPath);
+    bare.writeBool(bc, x.readOnly);
+    writeMountPluginDescriptor(bc, x.plugin);
+}
+export function readSoftwareDescriptor(bc) {
+    return {
+        packageName: bare.readString(bc),
+        root: bare.readString(bc),
+    };
+}
+export function writeSoftwareDescriptor(bc, x) {
+    bare.writeString(bc, x.packageName);
+    bare.writeString(bc, x.root);
+}
+export function readProjectedModuleDescriptor(bc) {
+    return {
+        packageName: bare.readString(bc),
+        entrypoint: bare.readString(bc),
+    };
+}
+export function writeProjectedModuleDescriptor(bc, x) {
+    bare.writeString(bc, x.packageName);
+    bare.writeString(bc, x.entrypoint);
+}
+export var WasmPermissionTier;
+(function (WasmPermissionTier) {
+    WasmPermissionTier["Full"] = "Full";
+    WasmPermissionTier["ReadWrite"] = "ReadWrite";
+    WasmPermissionTier["ReadOnly"] = "ReadOnly";
+    WasmPermissionTier["Isolated"] = "Isolated";
+})(WasmPermissionTier || (WasmPermissionTier = {}));
+export function readWasmPermissionTier(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return WasmPermissionTier.Full;
+        case 1:
+            return WasmPermissionTier.ReadWrite;
+        case 2:
+            return WasmPermissionTier.ReadOnly;
+        case 3:
+            return WasmPermissionTier.Isolated;
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeWasmPermissionTier(bc, x) {
+    switch (x) {
+        case WasmPermissionTier.Full: {
+            bare.writeU8(bc, 0);
+            break;
+        }
+        case WasmPermissionTier.ReadWrite: {
+            bare.writeU8(bc, 1);
+            break;
+        }
+        case WasmPermissionTier.ReadOnly: {
+            bare.writeU8(bc, 2);
+            break;
+        }
+        case WasmPermissionTier.Isolated: {
+            bare.writeU8(bc, 3);
+            break;
+        }
+    }
+}
+function read12(bc) {
+    const len = bare.readUintSafe(bc);
+    if (len === 0) {
+        return [];
+    }
+    const result = [readMountDescriptor(bc)];
+    for (let i = 1; i < len; i++) {
+        result[i] = readMountDescriptor(bc);
+    }
+    return result;
+}
+function write12(bc, x) {
+    bare.writeUintSafe(bc, x.length);
+    for (let i = 0; i < x.length; i++) {
+        writeMountDescriptor(bc, x[i]);
+    }
+}
+function read13(bc) {
+    const len = bare.readUintSafe(bc);
+    if (len === 0) {
+        return [];
+    }
+    const result = [readSoftwareDescriptor(bc)];
+    for (let i = 1; i < len; i++) {
+        result[i] = readSoftwareDescriptor(bc);
+    }
+    return result;
+}
+function write13(bc, x) {
+    bare.writeUintSafe(bc, x.length);
+    for (let i = 0; i < x.length; i++) {
+        writeSoftwareDescriptor(bc, x[i]);
+    }
+}
+function read14(bc) {
+    return bare.readBool(bc) ? readPermissionsPolicy(bc) : null;
+}
+function write14(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        writePermissionsPolicy(bc, x);
+    }
+}
+function read15(bc) {
+    const len = bare.readUintSafe(bc);
+    if (len === 0) {
+        return [];
+    }
+    const result = [readProjectedModuleDescriptor(bc)];
+    for (let i = 1; i < len; i++) {
+        result[i] = readProjectedModuleDescriptor(bc);
+    }
+    return result;
+}
+function write15(bc, x) {
+    bare.writeUintSafe(bc, x.length);
+    for (let i = 0; i < x.length; i++) {
+        writeProjectedModuleDescriptor(bc, x[i]);
+    }
+}
+function read16(bc) {
+    const len = bare.readUintSafe(bc);
+    const result = new Map();
+    for (let i = 0; i < len; i++) {
+        const offset = bc.offset;
+        const key = bare.readString(bc);
+        if (result.has(key)) {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "duplicated key");
+        }
+        result.set(key, readWasmPermissionTier(bc));
+    }
+    return result;
+}
+function write16(bc, x) {
+    bare.writeUintSafe(bc, x.size);
+    for (const kv of x) {
+        bare.writeString(bc, kv[0]);
+        writeWasmPermissionTier(bc, kv[1]);
+    }
+}
+export function readConfigureVmRequest(bc) {
+    return {
+        mounts: read12(bc),
+        software: read13(bc),
+        permissions: read14(bc),
+        moduleAccessCwd: read0(bc),
+        instructions: read6(bc),
+        projectedModules: read15(bc),
+        commandPermissions: read16(bc),
+        loopbackExemptPorts: bare.readU16Array(bc),
+    };
+}
+export function writeConfigureVmRequest(bc, x) {
+    write12(bc, x.mounts);
+    write13(bc, x.software);
+    write14(bc, x.permissions);
+    write0(bc, x.moduleAccessCwd);
+    write6(bc, x.instructions);
+    write15(bc, x.projectedModules);
+    write16(bc, x.commandPermissions);
+    bare.writeU16Array(bc, x.loopbackExemptPorts);
+}
+export function readRegisteredHostCallbackExample(bc) {
+    return {
+        description: bare.readString(bc),
+        input: readJsonUtf8(bc),
+    };
+}
+export function writeRegisteredHostCallbackExample(bc, x) {
+    bare.writeString(bc, x.description);
+    writeJsonUtf8(bc, x.input);
+}
+function read17(bc) {
+    return bare.readBool(bc) ? bare.readU64(bc) : null;
+}
+function write17(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        bare.writeU64(bc, x);
+    }
+}
+function read18(bc) {
+    const len = bare.readUintSafe(bc);
+    if (len === 0) {
+        return [];
+    }
+    const result = [readRegisteredHostCallbackExample(bc)];
+    for (let i = 1; i < len; i++) {
+        result[i] = readRegisteredHostCallbackExample(bc);
+    }
+    return result;
+}
+function write18(bc, x) {
+    bare.writeUintSafe(bc, x.length);
+    for (let i = 0; i < x.length; i++) {
+        writeRegisteredHostCallbackExample(bc, x[i]);
+    }
+}
+export function readRegisteredHostCallbackDefinition(bc) {
+    return {
+        description: bare.readString(bc),
+        inputSchema: readJsonUtf8(bc),
+        timeoutMs: read17(bc),
+        examples: read18(bc),
+    };
+}
+export function writeRegisteredHostCallbackDefinition(bc, x) {
+    bare.writeString(bc, x.description);
+    writeJsonUtf8(bc, x.inputSchema);
+    write17(bc, x.timeoutMs);
+    write18(bc, x.examples);
+}
+function read19(bc) {
+    const len = bare.readUintSafe(bc);
+    const result = new Map();
+    for (let i = 0; i < len; i++) {
+        const offset = bc.offset;
+        const key = bare.readString(bc);
+        if (result.has(key)) {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "duplicated key");
+        }
+        result.set(key, readRegisteredHostCallbackDefinition(bc));
+    }
+    return result;
+}
+function write19(bc, x) {
+    bare.writeUintSafe(bc, x.size);
+    for (const kv of x) {
+        bare.writeString(bc, kv[0]);
+        writeRegisteredHostCallbackDefinition(bc, kv[1]);
+    }
+}
+export function readRegisterHostCallbacksRequest(bc) {
+    return {
+        name: bare.readString(bc),
+        description: bare.readString(bc),
+        commandAliases: read6(bc),
+        registryCommandAliases: read6(bc),
+        callbacks: read19(bc),
+    };
+}
+export function writeRegisterHostCallbacksRequest(bc, x) {
+    bare.writeString(bc, x.name);
+    bare.writeString(bc, x.description);
+    write6(bc, x.commandAliases);
+    write6(bc, x.registryCommandAliases);
+    write19(bc, x.callbacks);
+}
+export function readSealLayerRequest(bc) {
+    return {
+        layerId: bare.readString(bc),
+    };
+}
+export function writeSealLayerRequest(bc, x) {
+    bare.writeString(bc, x.layerId);
+}
+export function readImportSnapshotRequest(bc) {
+    return {
+        entries: read4(bc),
+    };
+}
+export function writeImportSnapshotRequest(bc, x) {
+    write4(bc, x.entries);
+}
+export function readExportSnapshotRequest(bc) {
+    return {
+        layerId: bare.readString(bc),
+    };
+}
+export function writeExportSnapshotRequest(bc, x) {
+    bare.writeString(bc, x.layerId);
+}
+export function readCreateOverlayRequest(bc) {
+    return {
+        mode: readRootFilesystemMode(bc),
+        upperLayerId: read0(bc),
+        lowerLayerIds: read6(bc),
+    };
+}
+export function writeCreateOverlayRequest(bc, x) {
+    writeRootFilesystemMode(bc, x.mode);
+    write0(bc, x.upperLayerId);
+    write6(bc, x.lowerLayerIds);
+}
+export var GuestFilesystemOperation;
+(function (GuestFilesystemOperation) {
+    GuestFilesystemOperation["ReadFile"] = "ReadFile";
+    GuestFilesystemOperation["WriteFile"] = "WriteFile";
+    GuestFilesystemOperation["CreateDir"] = "CreateDir";
+    GuestFilesystemOperation["Mkdir"] = "Mkdir";
+    GuestFilesystemOperation["Exists"] = "Exists";
+    GuestFilesystemOperation["Stat"] = "Stat";
+    GuestFilesystemOperation["Lstat"] = "Lstat";
+    GuestFilesystemOperation["ReadDir"] = "ReadDir";
+    GuestFilesystemOperation["RemoveFile"] = "RemoveFile";
+    GuestFilesystemOperation["RemoveDir"] = "RemoveDir";
+    GuestFilesystemOperation["Rename"] = "Rename";
+    GuestFilesystemOperation["Realpath"] = "Realpath";
+    GuestFilesystemOperation["Symlink"] = "Symlink";
+    GuestFilesystemOperation["ReadLink"] = "ReadLink";
+    GuestFilesystemOperation["Link"] = "Link";
+    GuestFilesystemOperation["Chmod"] = "Chmod";
+    GuestFilesystemOperation["Chown"] = "Chown";
+    GuestFilesystemOperation["Utimes"] = "Utimes";
+    GuestFilesystemOperation["Truncate"] = "Truncate";
+    GuestFilesystemOperation["Pread"] = "Pread";
+})(GuestFilesystemOperation || (GuestFilesystemOperation = {}));
+export function readGuestFilesystemOperation(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return GuestFilesystemOperation.ReadFile;
+        case 1:
+            return GuestFilesystemOperation.WriteFile;
+        case 2:
+            return GuestFilesystemOperation.CreateDir;
+        case 3:
+            return GuestFilesystemOperation.Mkdir;
+        case 4:
+            return GuestFilesystemOperation.Exists;
+        case 5:
+            return GuestFilesystemOperation.Stat;
+        case 6:
+            return GuestFilesystemOperation.Lstat;
+        case 7:
+            return GuestFilesystemOperation.ReadDir;
+        case 8:
+            return GuestFilesystemOperation.RemoveFile;
+        case 9:
+            return GuestFilesystemOperation.RemoveDir;
+        case 10:
+            return GuestFilesystemOperation.Rename;
+        case 11:
+            return GuestFilesystemOperation.Realpath;
+        case 12:
+            return GuestFilesystemOperation.Symlink;
+        case 13:
+            return GuestFilesystemOperation.ReadLink;
+        case 14:
+            return GuestFilesystemOperation.Link;
+        case 15:
+            return GuestFilesystemOperation.Chmod;
+        case 16:
+            return GuestFilesystemOperation.Chown;
+        case 17:
+            return GuestFilesystemOperation.Utimes;
+        case 18:
+            return GuestFilesystemOperation.Truncate;
+        case 19:
+            return GuestFilesystemOperation.Pread;
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeGuestFilesystemOperation(bc, x) {
+    switch (x) {
+        case GuestFilesystemOperation.ReadFile: {
+            bare.writeU8(bc, 0);
+            break;
+        }
+        case GuestFilesystemOperation.WriteFile: {
+            bare.writeU8(bc, 1);
+            break;
+        }
+        case GuestFilesystemOperation.CreateDir: {
+            bare.writeU8(bc, 2);
+            break;
+        }
+        case GuestFilesystemOperation.Mkdir: {
+            bare.writeU8(bc, 3);
+            break;
+        }
+        case GuestFilesystemOperation.Exists: {
+            bare.writeU8(bc, 4);
+            break;
+        }
+        case GuestFilesystemOperation.Stat: {
+            bare.writeU8(bc, 5);
+            break;
+        }
+        case GuestFilesystemOperation.Lstat: {
+            bare.writeU8(bc, 6);
+            break;
+        }
+        case GuestFilesystemOperation.ReadDir: {
+            bare.writeU8(bc, 7);
+            break;
+        }
+        case GuestFilesystemOperation.RemoveFile: {
+            bare.writeU8(bc, 8);
+            break;
+        }
+        case GuestFilesystemOperation.RemoveDir: {
+            bare.writeU8(bc, 9);
+            break;
+        }
+        case GuestFilesystemOperation.Rename: {
+            bare.writeU8(bc, 10);
+            break;
+        }
+        case GuestFilesystemOperation.Realpath: {
+            bare.writeU8(bc, 11);
+            break;
+        }
+        case GuestFilesystemOperation.Symlink: {
+            bare.writeU8(bc, 12);
+            break;
+        }
+        case GuestFilesystemOperation.ReadLink: {
+            bare.writeU8(bc, 13);
+            break;
+        }
+        case GuestFilesystemOperation.Link: {
+            bare.writeU8(bc, 14);
+            break;
+        }
+        case GuestFilesystemOperation.Chmod: {
+            bare.writeU8(bc, 15);
+            break;
+        }
+        case GuestFilesystemOperation.Chown: {
+            bare.writeU8(bc, 16);
+            break;
+        }
+        case GuestFilesystemOperation.Utimes: {
+            bare.writeU8(bc, 17);
+            break;
+        }
+        case GuestFilesystemOperation.Truncate: {
+            bare.writeU8(bc, 18);
+            break;
+        }
+        case GuestFilesystemOperation.Pread: {
+            bare.writeU8(bc, 19);
+            break;
+        }
+    }
+}
+export function readGuestFilesystemCallRequest(bc) {
+    return {
+        operation: readGuestFilesystemOperation(bc),
+        path: bare.readString(bc),
+        destinationPath: read0(bc),
+        target: read0(bc),
+        content: read0(bc),
+        encoding: read3(bc),
+        recursive: bare.readBool(bc),
+        mode: read2(bc),
+        uid: read2(bc),
+        gid: read2(bc),
+        atimeMs: read17(bc),
+        mtimeMs: read17(bc),
+        len: read17(bc),
+        offset: read17(bc),
+    };
+}
+export function writeGuestFilesystemCallRequest(bc, x) {
+    writeGuestFilesystemOperation(bc, x.operation);
+    bare.writeString(bc, x.path);
+    write0(bc, x.destinationPath);
+    write0(bc, x.target);
+    write0(bc, x.content);
+    write3(bc, x.encoding);
+    bare.writeBool(bc, x.recursive);
+    write2(bc, x.mode);
+    write2(bc, x.uid);
+    write2(bc, x.gid);
+    write17(bc, x.atimeMs);
+    write17(bc, x.mtimeMs);
+    write17(bc, x.len);
+    write17(bc, x.offset);
+}
+function read20(bc) {
+    return bare.readBool(bc) ? readGuestRuntimeKind(bc) : null;
+}
+function write20(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        writeGuestRuntimeKind(bc, x);
+    }
+}
+function read21(bc) {
+    return bare.readBool(bc) ? readWasmPermissionTier(bc) : null;
+}
+function write21(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        writeWasmPermissionTier(bc, x);
+    }
+}
+export function readExecuteRequest(bc) {
+    return {
+        processId: bare.readString(bc),
+        command: read0(bc),
+        runtime: read20(bc),
+        entrypoint: read0(bc),
+        args: read6(bc),
+        env: read1(bc),
+        cwd: read0(bc),
+        wasmPermissionTier: read21(bc),
+    };
+}
+export function writeExecuteRequest(bc, x) {
+    bare.writeString(bc, x.processId);
+    write0(bc, x.command);
+    write20(bc, x.runtime);
+    write0(bc, x.entrypoint);
+    write6(bc, x.args);
+    write1(bc, x.env);
+    write0(bc, x.cwd);
+    write21(bc, x.wasmPermissionTier);
+}
+export function readWriteStdinRequest(bc) {
+    return {
+        processId: bare.readString(bc),
+        chunk: bare.readData(bc),
+    };
+}
+export function writeWriteStdinRequest(bc, x) {
+    bare.writeString(bc, x.processId);
+    bare.writeData(bc, x.chunk);
+}
+export function readCloseStdinRequest(bc) {
+    return {
+        processId: bare.readString(bc),
+    };
+}
+export function writeCloseStdinRequest(bc, x) {
+    bare.writeString(bc, x.processId);
+}
+export function readKillProcessRequest(bc) {
+    return {
+        processId: bare.readString(bc),
+        signal: bare.readString(bc),
+    };
+}
+export function writeKillProcessRequest(bc, x) {
+    bare.writeString(bc, x.processId);
+    bare.writeString(bc, x.signal);
+}
+function read22(bc) {
+    return bare.readBool(bc) ? bare.readU16(bc) : null;
+}
+function write22(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        bare.writeU16(bc, x);
+    }
+}
+export function readFindListenerRequest(bc) {
+    return {
+        host: read0(bc),
+        port: read22(bc),
+        path: read0(bc),
+    };
+}
+export function writeFindListenerRequest(bc, x) {
+    write0(bc, x.host);
+    write22(bc, x.port);
+    write0(bc, x.path);
+}
+export function readFindBoundUdpRequest(bc) {
+    return {
+        host: read0(bc),
+        port: read22(bc),
+    };
+}
+export function writeFindBoundUdpRequest(bc, x) {
+    write0(bc, x.host);
+    write22(bc, x.port);
+}
+export function readGetSignalStateRequest(bc) {
+    return {
+        processId: bare.readString(bc),
+    };
+}
+export function writeGetSignalStateRequest(bc, x) {
+    bare.writeString(bc, x.processId);
+}
+export var FilesystemOperation;
+(function (FilesystemOperation) {
+    FilesystemOperation["Read"] = "Read";
+    FilesystemOperation["Write"] = "Write";
+    FilesystemOperation["Stat"] = "Stat";
+    FilesystemOperation["ReadDir"] = "ReadDir";
+    FilesystemOperation["Mkdir"] = "Mkdir";
+    FilesystemOperation["Remove"] = "Remove";
+    FilesystemOperation["Rename"] = "Rename";
+})(FilesystemOperation || (FilesystemOperation = {}));
+export function readFilesystemOperation(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return FilesystemOperation.Read;
+        case 1:
+            return FilesystemOperation.Write;
+        case 2:
+            return FilesystemOperation.Stat;
+        case 3:
+            return FilesystemOperation.ReadDir;
+        case 4:
+            return FilesystemOperation.Mkdir;
+        case 5:
+            return FilesystemOperation.Remove;
+        case 6:
+            return FilesystemOperation.Rename;
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeFilesystemOperation(bc, x) {
+    switch (x) {
+        case FilesystemOperation.Read: {
+            bare.writeU8(bc, 0);
+            break;
+        }
+        case FilesystemOperation.Write: {
+            bare.writeU8(bc, 1);
+            break;
+        }
+        case FilesystemOperation.Stat: {
+            bare.writeU8(bc, 2);
+            break;
+        }
+        case FilesystemOperation.ReadDir: {
+            bare.writeU8(bc, 3);
+            break;
+        }
+        case FilesystemOperation.Mkdir: {
+            bare.writeU8(bc, 4);
+            break;
+        }
+        case FilesystemOperation.Remove: {
+            bare.writeU8(bc, 5);
+            break;
+        }
+        case FilesystemOperation.Rename: {
+            bare.writeU8(bc, 6);
+            break;
+        }
+    }
+}
+export function readHostFilesystemCallRequest(bc) {
+    return {
+        operation: readFilesystemOperation(bc),
+        path: bare.readString(bc),
+        payloadSizeBytes: bare.readU64(bc),
+    };
+}
+export function writeHostFilesystemCallRequest(bc, x) {
+    writeFilesystemOperation(bc, x.operation);
+    bare.writeString(bc, x.path);
+    bare.writeU64(bc, x.payloadSizeBytes);
+}
+export function readPersistenceLoadRequest(bc) {
+    return {
+        key: bare.readString(bc),
+    };
+}
+export function writePersistenceLoadRequest(bc, x) {
+    bare.writeString(bc, x.key);
+}
+export function readPersistenceFlushRequest(bc) {
+    return {
+        key: bare.readString(bc),
+        payloadSizeBytes: bare.readU64(bc),
+    };
+}
+export function writePersistenceFlushRequest(bc, x) {
+    bare.writeString(bc, x.key);
+    bare.writeU64(bc, x.payloadSizeBytes);
+}
+export function readVmFetchRequest(bc) {
+    return {
+        port: bare.readU16(bc),
+        method: bare.readString(bc),
+        path: bare.readString(bc),
+        headersJson: bare.readString(bc),
+        body: read0(bc),
+    };
+}
+export function writeVmFetchRequest(bc, x) {
+    bare.writeU16(bc, x.port);
+    bare.writeString(bc, x.method);
+    bare.writeString(bc, x.path);
+    bare.writeString(bc, x.headersJson);
+    write0(bc, x.body);
+}
+export function readRequestPayload(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return { tag: "AuthenticateRequest", val: readAuthenticateRequest(bc) };
+        case 1:
+            return { tag: "OpenSessionRequest", val: readOpenSessionRequest(bc) };
+        case 2:
+            return { tag: "CreateVmRequest", val: readCreateVmRequest(bc) };
+        case 3:
+            return { tag: "DisposeVmRequest", val: readDisposeVmRequest(bc) };
+        case 4:
+            return { tag: "BootstrapRootFilesystemRequest", val: readBootstrapRootFilesystemRequest(bc) };
+        case 5:
+            return { tag: "ConfigureVmRequest", val: readConfigureVmRequest(bc) };
+        case 6:
+            return { tag: "RegisterHostCallbacksRequest", val: readRegisterHostCallbacksRequest(bc) };
+        case 7:
+            return { tag: "CreateLayerRequest", val: null };
+        case 8:
+            return { tag: "SealLayerRequest", val: readSealLayerRequest(bc) };
+        case 9:
+            return { tag: "ImportSnapshotRequest", val: readImportSnapshotRequest(bc) };
+        case 10:
+            return { tag: "ExportSnapshotRequest", val: readExportSnapshotRequest(bc) };
+        case 11:
+            return { tag: "CreateOverlayRequest", val: readCreateOverlayRequest(bc) };
+        case 12:
+            return { tag: "GuestFilesystemCallRequest", val: readGuestFilesystemCallRequest(bc) };
+        case 13:
+            return { tag: "SnapshotRootFilesystemRequest", val: null };
+        case 14:
+            return { tag: "ExecuteRequest", val: readExecuteRequest(bc) };
+        case 15:
+            return { tag: "WriteStdinRequest", val: readWriteStdinRequest(bc) };
+        case 16:
+            return { tag: "CloseStdinRequest", val: readCloseStdinRequest(bc) };
+        case 17:
+            return { tag: "KillProcessRequest", val: readKillProcessRequest(bc) };
+        case 18:
+            return { tag: "GetProcessSnapshotRequest", val: null };
+        case 19:
+            return { tag: "FindListenerRequest", val: readFindListenerRequest(bc) };
+        case 20:
+            return { tag: "FindBoundUdpRequest", val: readFindBoundUdpRequest(bc) };
+        case 21:
+            return { tag: "GetSignalStateRequest", val: readGetSignalStateRequest(bc) };
+        case 22:
+            return { tag: "GetZombieTimerCountRequest", val: null };
+        case 23:
+            return { tag: "HostFilesystemCallRequest", val: readHostFilesystemCallRequest(bc) };
+        case 24:
+            return { tag: "PersistenceLoadRequest", val: readPersistenceLoadRequest(bc) };
+        case 25:
+            return { tag: "PersistenceFlushRequest", val: readPersistenceFlushRequest(bc) };
+        case 26:
+            return { tag: "VmFetchRequest", val: readVmFetchRequest(bc) };
+        case 27:
+            return { tag: "ExtEnvelope", val: readExtEnvelope(bc) };
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeRequestPayload(bc, x) {
+    switch (x.tag) {
+        case "AuthenticateRequest": {
+            bare.writeU8(bc, 0);
+            writeAuthenticateRequest(bc, x.val);
+            break;
+        }
+        case "OpenSessionRequest": {
+            bare.writeU8(bc, 1);
+            writeOpenSessionRequest(bc, x.val);
+            break;
+        }
+        case "CreateVmRequest": {
+            bare.writeU8(bc, 2);
+            writeCreateVmRequest(bc, x.val);
+            break;
+        }
+        case "DisposeVmRequest": {
+            bare.writeU8(bc, 3);
+            writeDisposeVmRequest(bc, x.val);
+            break;
+        }
+        case "BootstrapRootFilesystemRequest": {
+            bare.writeU8(bc, 4);
+            writeBootstrapRootFilesystemRequest(bc, x.val);
+            break;
+        }
+        case "ConfigureVmRequest": {
+            bare.writeU8(bc, 5);
+            writeConfigureVmRequest(bc, x.val);
+            break;
+        }
+        case "RegisterHostCallbacksRequest": {
+            bare.writeU8(bc, 6);
+            writeRegisterHostCallbacksRequest(bc, x.val);
+            break;
+        }
+        case "CreateLayerRequest": {
+            bare.writeU8(bc, 7);
+            break;
+        }
+        case "SealLayerRequest": {
+            bare.writeU8(bc, 8);
+            writeSealLayerRequest(bc, x.val);
+            break;
+        }
+        case "ImportSnapshotRequest": {
+            bare.writeU8(bc, 9);
+            writeImportSnapshotRequest(bc, x.val);
+            break;
+        }
+        case "ExportSnapshotRequest": {
+            bare.writeU8(bc, 10);
+            writeExportSnapshotRequest(bc, x.val);
+            break;
+        }
+        case "CreateOverlayRequest": {
+            bare.writeU8(bc, 11);
+            writeCreateOverlayRequest(bc, x.val);
+            break;
+        }
+        case "GuestFilesystemCallRequest": {
+            bare.writeU8(bc, 12);
+            writeGuestFilesystemCallRequest(bc, x.val);
+            break;
+        }
+        case "SnapshotRootFilesystemRequest": {
+            bare.writeU8(bc, 13);
+            break;
+        }
+        case "ExecuteRequest": {
+            bare.writeU8(bc, 14);
+            writeExecuteRequest(bc, x.val);
+            break;
+        }
+        case "WriteStdinRequest": {
+            bare.writeU8(bc, 15);
+            writeWriteStdinRequest(bc, x.val);
+            break;
+        }
+        case "CloseStdinRequest": {
+            bare.writeU8(bc, 16);
+            writeCloseStdinRequest(bc, x.val);
+            break;
+        }
+        case "KillProcessRequest": {
+            bare.writeU8(bc, 17);
+            writeKillProcessRequest(bc, x.val);
+            break;
+        }
+        case "GetProcessSnapshotRequest": {
+            bare.writeU8(bc, 18);
+            break;
+        }
+        case "FindListenerRequest": {
+            bare.writeU8(bc, 19);
+            writeFindListenerRequest(bc, x.val);
+            break;
+        }
+        case "FindBoundUdpRequest": {
+            bare.writeU8(bc, 20);
+            writeFindBoundUdpRequest(bc, x.val);
+            break;
+        }
+        case "GetSignalStateRequest": {
+            bare.writeU8(bc, 21);
+            writeGetSignalStateRequest(bc, x.val);
+            break;
+        }
+        case "GetZombieTimerCountRequest": {
+            bare.writeU8(bc, 22);
+            break;
+        }
+        case "HostFilesystemCallRequest": {
+            bare.writeU8(bc, 23);
+            writeHostFilesystemCallRequest(bc, x.val);
+            break;
+        }
+        case "PersistenceLoadRequest": {
+            bare.writeU8(bc, 24);
+            writePersistenceLoadRequest(bc, x.val);
+            break;
+        }
+        case "PersistenceFlushRequest": {
+            bare.writeU8(bc, 25);
+            writePersistenceFlushRequest(bc, x.val);
+            break;
+        }
+        case "VmFetchRequest": {
+            bare.writeU8(bc, 26);
+            writeVmFetchRequest(bc, x.val);
+            break;
+        }
+        case "ExtEnvelope": {
+            bare.writeU8(bc, 27);
+            writeExtEnvelope(bc, x.val);
+            break;
+        }
+    }
+}
+export function readRequestFrame(bc) {
+    return {
+        schema: readProtocolSchema(bc),
+        requestId: readRequestId(bc),
+        ownership: readOwnershipScope(bc),
+        payload: readRequestPayload(bc),
+    };
+}
+export function writeRequestFrame(bc, x) {
+    writeProtocolSchema(bc, x.schema);
+    writeRequestId(bc, x.requestId);
+    writeOwnershipScope(bc, x.ownership);
+    writeRequestPayload(bc, x.payload);
+}
+export function readAuthenticatedResponse(bc) {
+    return {
+        sidecarId: bare.readString(bc),
+        connectionId: bare.readString(bc),
+        maxFrameBytes: bare.readU32(bc),
+    };
+}
+export function writeAuthenticatedResponse(bc, x) {
+    bare.writeString(bc, x.sidecarId);
+    bare.writeString(bc, x.connectionId);
+    bare.writeU32(bc, x.maxFrameBytes);
+}
+export function readSessionOpenedResponse(bc) {
+    return {
+        sessionId: bare.readString(bc),
+        ownerConnectionId: bare.readString(bc),
+    };
+}
+export function writeSessionOpenedResponse(bc, x) {
+    bare.writeString(bc, x.sessionId);
+    bare.writeString(bc, x.ownerConnectionId);
+}
+export function readVmCreatedResponse(bc) {
+    return {
+        vmId: bare.readString(bc),
+    };
+}
+export function writeVmCreatedResponse(bc, x) {
+    bare.writeString(bc, x.vmId);
+}
+export function readVmDisposedResponse(bc) {
+    return {
+        vmId: bare.readString(bc),
+    };
+}
+export function writeVmDisposedResponse(bc, x) {
+    bare.writeString(bc, x.vmId);
+}
+export function readRootFilesystemBootstrappedResponse(bc) {
+    return {
+        entryCount: bare.readU32(bc),
+    };
+}
+export function writeRootFilesystemBootstrappedResponse(bc, x) {
+    bare.writeU32(bc, x.entryCount);
+}
+export function readVmConfiguredResponse(bc) {
+    return {
+        appliedMounts: bare.readU32(bc),
+        appliedSoftware: bare.readU32(bc),
+    };
+}
+export function writeVmConfiguredResponse(bc, x) {
+    bare.writeU32(bc, x.appliedMounts);
+    bare.writeU32(bc, x.appliedSoftware);
+}
+export function readHostCallbacksRegisteredResponse(bc) {
+    return {
+        registration: bare.readString(bc),
+        commandCount: bare.readU32(bc),
+    };
+}
+export function writeHostCallbacksRegisteredResponse(bc, x) {
+    bare.writeString(bc, x.registration);
+    bare.writeU32(bc, x.commandCount);
+}
+export function readLayerCreatedResponse(bc) {
+    return {
+        layerId: bare.readString(bc),
+    };
+}
+export function writeLayerCreatedResponse(bc, x) {
+    bare.writeString(bc, x.layerId);
+}
+export function readLayerSealedResponse(bc) {
+    return {
+        layerId: bare.readString(bc),
+    };
+}
+export function writeLayerSealedResponse(bc, x) {
+    bare.writeString(bc, x.layerId);
+}
+export function readSnapshotImportedResponse(bc) {
+    return {
+        layerId: bare.readString(bc),
+    };
+}
+export function writeSnapshotImportedResponse(bc, x) {
+    bare.writeString(bc, x.layerId);
+}
+export function readSnapshotExportedResponse(bc) {
+    return {
+        layerId: bare.readString(bc),
+        entries: read4(bc),
+    };
+}
+export function writeSnapshotExportedResponse(bc, x) {
+    bare.writeString(bc, x.layerId);
+    write4(bc, x.entries);
+}
+export function readOverlayCreatedResponse(bc) {
+    return {
+        layerId: bare.readString(bc),
+    };
+}
+export function writeOverlayCreatedResponse(bc, x) {
+    bare.writeString(bc, x.layerId);
+}
+export function readGuestFilesystemStat(bc) {
+    return {
+        mode: bare.readU32(bc),
+        size: bare.readU64(bc),
+        blocks: bare.readU64(bc),
+        dev: bare.readU64(bc),
+        rdev: bare.readU64(bc),
+        isDirectory: bare.readBool(bc),
+        isSymbolicLink: bare.readBool(bc),
+        atimeMs: bare.readU64(bc),
+        mtimeMs: bare.readU64(bc),
+        ctimeMs: bare.readU64(bc),
+        birthtimeMs: bare.readU64(bc),
+        ino: bare.readU64(bc),
+        nlink: bare.readU64(bc),
+        uid: bare.readU32(bc),
+        gid: bare.readU32(bc),
+    };
+}
+export function writeGuestFilesystemStat(bc, x) {
+    bare.writeU32(bc, x.mode);
+    bare.writeU64(bc, x.size);
+    bare.writeU64(bc, x.blocks);
+    bare.writeU64(bc, x.dev);
+    bare.writeU64(bc, x.rdev);
+    bare.writeBool(bc, x.isDirectory);
+    bare.writeBool(bc, x.isSymbolicLink);
+    bare.writeU64(bc, x.atimeMs);
+    bare.writeU64(bc, x.mtimeMs);
+    bare.writeU64(bc, x.ctimeMs);
+    bare.writeU64(bc, x.birthtimeMs);
+    bare.writeU64(bc, x.ino);
+    bare.writeU64(bc, x.nlink);
+    bare.writeU32(bc, x.uid);
+    bare.writeU32(bc, x.gid);
+}
+function read23(bc) {
+    return bare.readBool(bc) ? read6(bc) : null;
+}
+function write23(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        write6(bc, x);
+    }
+}
+function read24(bc) {
+    return bare.readBool(bc) ? readGuestFilesystemStat(bc) : null;
+}
+function write24(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        writeGuestFilesystemStat(bc, x);
+    }
+}
+function read25(bc) {
+    return bare.readBool(bc) ? bare.readBool(bc) : null;
+}
+function write25(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        bare.writeBool(bc, x);
+    }
+}
+export function readGuestFilesystemResultResponse(bc) {
+    return {
+        operation: readGuestFilesystemOperation(bc),
+        path: bare.readString(bc),
+        content: read0(bc),
+        encoding: read3(bc),
+        entries: read23(bc),
+        stat: read24(bc),
+        exists: read25(bc),
+        target: read0(bc),
+    };
+}
+export function writeGuestFilesystemResultResponse(bc, x) {
+    writeGuestFilesystemOperation(bc, x.operation);
+    bare.writeString(bc, x.path);
+    write0(bc, x.content);
+    write3(bc, x.encoding);
+    write23(bc, x.entries);
+    write24(bc, x.stat);
+    write25(bc, x.exists);
+    write0(bc, x.target);
+}
+export function readRootFilesystemSnapshotResponse(bc) {
+    return {
+        entries: read4(bc),
+    };
+}
+export function writeRootFilesystemSnapshotResponse(bc, x) {
+    write4(bc, x.entries);
+}
+export function readProcessStartedResponse(bc) {
+    return {
+        processId: bare.readString(bc),
+        pid: read2(bc),
+    };
+}
+export function writeProcessStartedResponse(bc, x) {
+    bare.writeString(bc, x.processId);
+    write2(bc, x.pid);
+}
+export function readStdinWrittenResponse(bc) {
+    return {
+        processId: bare.readString(bc),
+        acceptedBytes: bare.readU64(bc),
+    };
+}
+export function writeStdinWrittenResponse(bc, x) {
+    bare.writeString(bc, x.processId);
+    bare.writeU64(bc, x.acceptedBytes);
+}
+export function readStdinClosedResponse(bc) {
+    return {
+        processId: bare.readString(bc),
+    };
+}
+export function writeStdinClosedResponse(bc, x) {
+    bare.writeString(bc, x.processId);
+}
+export function readProcessKilledResponse(bc) {
+    return {
+        processId: bare.readString(bc),
+    };
+}
+export function writeProcessKilledResponse(bc, x) {
+    bare.writeString(bc, x.processId);
+}
+export var ProcessSnapshotStatus;
+(function (ProcessSnapshotStatus) {
+    ProcessSnapshotStatus["Running"] = "Running";
+    ProcessSnapshotStatus["Exited"] = "Exited";
+    ProcessSnapshotStatus["Stopped"] = "Stopped";
+})(ProcessSnapshotStatus || (ProcessSnapshotStatus = {}));
+export function readProcessSnapshotStatus(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return ProcessSnapshotStatus.Running;
+        case 1:
+            return ProcessSnapshotStatus.Exited;
+        case 2:
+            return ProcessSnapshotStatus.Stopped;
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeProcessSnapshotStatus(bc, x) {
+    switch (x) {
+        case ProcessSnapshotStatus.Running: {
+            bare.writeU8(bc, 0);
+            break;
+        }
+        case ProcessSnapshotStatus.Exited: {
+            bare.writeU8(bc, 1);
+            break;
+        }
+        case ProcessSnapshotStatus.Stopped: {
+            bare.writeU8(bc, 2);
+            break;
+        }
+    }
+}
+function read26(bc) {
+    return bare.readBool(bc) ? bare.readI32(bc) : null;
+}
+function write26(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        bare.writeI32(bc, x);
+    }
+}
+export function readProcessSnapshotEntry(bc) {
+    return {
+        processId: bare.readString(bc),
+        pid: bare.readU32(bc),
+        ppid: bare.readU32(bc),
+        pgid: bare.readU32(bc),
+        sid: bare.readU32(bc),
+        driver: bare.readString(bc),
+        command: bare.readString(bc),
+        args: read6(bc),
+        cwd: bare.readString(bc),
+        status: readProcessSnapshotStatus(bc),
+        exitCode: read26(bc),
+    };
+}
+export function writeProcessSnapshotEntry(bc, x) {
+    bare.writeString(bc, x.processId);
+    bare.writeU32(bc, x.pid);
+    bare.writeU32(bc, x.ppid);
+    bare.writeU32(bc, x.pgid);
+    bare.writeU32(bc, x.sid);
+    bare.writeString(bc, x.driver);
+    bare.writeString(bc, x.command);
+    write6(bc, x.args);
+    bare.writeString(bc, x.cwd);
+    writeProcessSnapshotStatus(bc, x.status);
+    write26(bc, x.exitCode);
+}
+function read27(bc) {
+    const len = bare.readUintSafe(bc);
+    if (len === 0) {
+        return [];
+    }
+    const result = [readProcessSnapshotEntry(bc)];
+    for (let i = 1; i < len; i++) {
+        result[i] = readProcessSnapshotEntry(bc);
+    }
+    return result;
+}
+function write27(bc, x) {
+    bare.writeUintSafe(bc, x.length);
+    for (let i = 0; i < x.length; i++) {
+        writeProcessSnapshotEntry(bc, x[i]);
+    }
+}
+export function readProcessSnapshotResponse(bc) {
+    return {
+        processes: read27(bc),
+    };
+}
+export function writeProcessSnapshotResponse(bc, x) {
+    write27(bc, x.processes);
+}
+export function readSocketStateEntry(bc) {
+    return {
+        processId: bare.readString(bc),
+        host: read0(bc),
+        port: read22(bc),
+        path: read0(bc),
+    };
+}
+export function writeSocketStateEntry(bc, x) {
+    bare.writeString(bc, x.processId);
+    write0(bc, x.host);
+    write22(bc, x.port);
+    write0(bc, x.path);
+}
+function read28(bc) {
+    return bare.readBool(bc) ? readSocketStateEntry(bc) : null;
+}
+function write28(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        writeSocketStateEntry(bc, x);
+    }
+}
+export function readListenerSnapshotResponse(bc) {
+    return {
+        listener: read28(bc),
+    };
+}
+export function writeListenerSnapshotResponse(bc, x) {
+    write28(bc, x.listener);
+}
+export function readBoundUdpSnapshotResponse(bc) {
+    return {
+        socket: read28(bc),
+    };
+}
+export function writeBoundUdpSnapshotResponse(bc, x) {
+    write28(bc, x.socket);
+}
+export var SignalDispositionAction;
+(function (SignalDispositionAction) {
+    SignalDispositionAction["Default"] = "Default";
+    SignalDispositionAction["Ignore"] = "Ignore";
+    SignalDispositionAction["User"] = "User";
+})(SignalDispositionAction || (SignalDispositionAction = {}));
+export function readSignalDispositionAction(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return SignalDispositionAction.Default;
+        case 1:
+            return SignalDispositionAction.Ignore;
+        case 2:
+            return SignalDispositionAction.User;
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeSignalDispositionAction(bc, x) {
+    switch (x) {
+        case SignalDispositionAction.Default: {
+            bare.writeU8(bc, 0);
+            break;
+        }
+        case SignalDispositionAction.Ignore: {
+            bare.writeU8(bc, 1);
+            break;
+        }
+        case SignalDispositionAction.User: {
+            bare.writeU8(bc, 2);
+            break;
+        }
+    }
+}
+export function readSignalHandlerRegistration(bc) {
+    return {
+        action: readSignalDispositionAction(bc),
+        mask: bare.readU32Array(bc),
+        flags: bare.readU32(bc),
+    };
+}
+export function writeSignalHandlerRegistration(bc, x) {
+    writeSignalDispositionAction(bc, x.action);
+    bare.writeU32Array(bc, x.mask);
+    bare.writeU32(bc, x.flags);
+}
+function read29(bc) {
+    const len = bare.readUintSafe(bc);
+    const result = new Map();
+    for (let i = 0; i < len; i++) {
+        const offset = bc.offset;
+        const key = bare.readU32(bc);
+        if (result.has(key)) {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "duplicated key");
+        }
+        result.set(key, readSignalHandlerRegistration(bc));
+    }
+    return result;
+}
+function write29(bc, x) {
+    bare.writeUintSafe(bc, x.size);
+    for (const kv of x) {
+        bare.writeU32(bc, kv[0]);
+        writeSignalHandlerRegistration(bc, kv[1]);
+    }
+}
+export function readSignalStateResponse(bc) {
+    return {
+        processId: bare.readString(bc),
+        handlers: read29(bc),
+    };
+}
+export function writeSignalStateResponse(bc, x) {
+    bare.writeString(bc, x.processId);
+    write29(bc, x.handlers);
+}
+export function readZombieTimerCountResponse(bc) {
+    return {
+        count: bare.readU64(bc),
+    };
+}
+export function writeZombieTimerCountResponse(bc, x) {
+    bare.writeU64(bc, x.count);
+}
+export function readFilesystemResultResponse(bc) {
+    return {
+        operation: readFilesystemOperation(bc),
+        status: bare.readString(bc),
+        payloadSizeBytes: bare.readU64(bc),
+    };
+}
+export function writeFilesystemResultResponse(bc, x) {
+    writeFilesystemOperation(bc, x.operation);
+    bare.writeString(bc, x.status);
+    bare.writeU64(bc, x.payloadSizeBytes);
+}
+export function readPermissionDecisionResponse(bc) {
+    return {
+        capability: bare.readString(bc),
+        decision: readPermissionMode(bc),
+    };
+}
+export function writePermissionDecisionResponse(bc, x) {
+    bare.writeString(bc, x.capability);
+    writePermissionMode(bc, x.decision);
+}
+export function readPersistenceStateResponse(bc) {
+    return {
+        key: bare.readString(bc),
+        found: bare.readBool(bc),
+        payloadSizeBytes: bare.readU64(bc),
+    };
+}
+export function writePersistenceStateResponse(bc, x) {
+    bare.writeString(bc, x.key);
+    bare.writeBool(bc, x.found);
+    bare.writeU64(bc, x.payloadSizeBytes);
+}
+export function readPersistenceFlushedResponse(bc) {
+    return {
+        key: bare.readString(bc),
+        committedBytes: bare.readU64(bc),
+    };
+}
+export function writePersistenceFlushedResponse(bc, x) {
+    bare.writeString(bc, x.key);
+    bare.writeU64(bc, x.committedBytes);
+}
+export function readRejectedResponse(bc) {
+    return {
+        code: bare.readString(bc),
+        message: bare.readString(bc),
+    };
+}
+export function writeRejectedResponse(bc, x) {
+    bare.writeString(bc, x.code);
+    bare.writeString(bc, x.message);
+}
+export function readVmFetchResponse(bc) {
+    return {
+        responseJson: bare.readString(bc),
+    };
+}
+export function writeVmFetchResponse(bc, x) {
+    bare.writeString(bc, x.responseJson);
+}
+export function readResponsePayload(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return { tag: "AuthenticatedResponse", val: readAuthenticatedResponse(bc) };
+        case 1:
+            return { tag: "SessionOpenedResponse", val: readSessionOpenedResponse(bc) };
+        case 2:
+            return { tag: "VmCreatedResponse", val: readVmCreatedResponse(bc) };
+        case 3:
+            return { tag: "VmDisposedResponse", val: readVmDisposedResponse(bc) };
+        case 4:
+            return { tag: "RootFilesystemBootstrappedResponse", val: readRootFilesystemBootstrappedResponse(bc) };
+        case 5:
+            return { tag: "VmConfiguredResponse", val: readVmConfiguredResponse(bc) };
+        case 6:
+            return { tag: "HostCallbacksRegisteredResponse", val: readHostCallbacksRegisteredResponse(bc) };
+        case 7:
+            return { tag: "LayerCreatedResponse", val: readLayerCreatedResponse(bc) };
+        case 8:
+            return { tag: "LayerSealedResponse", val: readLayerSealedResponse(bc) };
+        case 9:
+            return { tag: "SnapshotImportedResponse", val: readSnapshotImportedResponse(bc) };
+        case 10:
+            return { tag: "SnapshotExportedResponse", val: readSnapshotExportedResponse(bc) };
+        case 11:
+            return { tag: "OverlayCreatedResponse", val: readOverlayCreatedResponse(bc) };
+        case 12:
+            return { tag: "GuestFilesystemResultResponse", val: readGuestFilesystemResultResponse(bc) };
+        case 13:
+            return { tag: "RootFilesystemSnapshotResponse", val: readRootFilesystemSnapshotResponse(bc) };
+        case 14:
+            return { tag: "ProcessStartedResponse", val: readProcessStartedResponse(bc) };
+        case 15:
+            return { tag: "StdinWrittenResponse", val: readStdinWrittenResponse(bc) };
+        case 16:
+            return { tag: "StdinClosedResponse", val: readStdinClosedResponse(bc) };
+        case 17:
+            return { tag: "ProcessKilledResponse", val: readProcessKilledResponse(bc) };
+        case 18:
+            return { tag: "ProcessSnapshotResponse", val: readProcessSnapshotResponse(bc) };
+        case 19:
+            return { tag: "ListenerSnapshotResponse", val: readListenerSnapshotResponse(bc) };
+        case 20:
+            return { tag: "BoundUdpSnapshotResponse", val: readBoundUdpSnapshotResponse(bc) };
+        case 21:
+            return { tag: "SignalStateResponse", val: readSignalStateResponse(bc) };
+        case 22:
+            return { tag: "ZombieTimerCountResponse", val: readZombieTimerCountResponse(bc) };
+        case 23:
+            return { tag: "FilesystemResultResponse", val: readFilesystemResultResponse(bc) };
+        case 24:
+            return { tag: "PermissionDecisionResponse", val: readPermissionDecisionResponse(bc) };
+        case 25:
+            return { tag: "PersistenceStateResponse", val: readPersistenceStateResponse(bc) };
+        case 26:
+            return { tag: "PersistenceFlushedResponse", val: readPersistenceFlushedResponse(bc) };
+        case 27:
+            return { tag: "RejectedResponse", val: readRejectedResponse(bc) };
+        case 28:
+            return { tag: "VmFetchResponse", val: readVmFetchResponse(bc) };
+        case 29:
+            return { tag: "ExtEnvelope", val: readExtEnvelope(bc) };
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeResponsePayload(bc, x) {
+    switch (x.tag) {
+        case "AuthenticatedResponse": {
+            bare.writeU8(bc, 0);
+            writeAuthenticatedResponse(bc, x.val);
+            break;
+        }
+        case "SessionOpenedResponse": {
+            bare.writeU8(bc, 1);
+            writeSessionOpenedResponse(bc, x.val);
+            break;
+        }
+        case "VmCreatedResponse": {
+            bare.writeU8(bc, 2);
+            writeVmCreatedResponse(bc, x.val);
+            break;
+        }
+        case "VmDisposedResponse": {
+            bare.writeU8(bc, 3);
+            writeVmDisposedResponse(bc, x.val);
+            break;
+        }
+        case "RootFilesystemBootstrappedResponse": {
+            bare.writeU8(bc, 4);
+            writeRootFilesystemBootstrappedResponse(bc, x.val);
+            break;
+        }
+        case "VmConfiguredResponse": {
+            bare.writeU8(bc, 5);
+            writeVmConfiguredResponse(bc, x.val);
+            break;
+        }
+        case "HostCallbacksRegisteredResponse": {
+            bare.writeU8(bc, 6);
+            writeHostCallbacksRegisteredResponse(bc, x.val);
+            break;
+        }
+        case "LayerCreatedResponse": {
+            bare.writeU8(bc, 7);
+            writeLayerCreatedResponse(bc, x.val);
+            break;
+        }
+        case "LayerSealedResponse": {
+            bare.writeU8(bc, 8);
+            writeLayerSealedResponse(bc, x.val);
+            break;
+        }
+        case "SnapshotImportedResponse": {
+            bare.writeU8(bc, 9);
+            writeSnapshotImportedResponse(bc, x.val);
+            break;
+        }
+        case "SnapshotExportedResponse": {
+            bare.writeU8(bc, 10);
+            writeSnapshotExportedResponse(bc, x.val);
+            break;
+        }
+        case "OverlayCreatedResponse": {
+            bare.writeU8(bc, 11);
+            writeOverlayCreatedResponse(bc, x.val);
+            break;
+        }
+        case "GuestFilesystemResultResponse": {
+            bare.writeU8(bc, 12);
+            writeGuestFilesystemResultResponse(bc, x.val);
+            break;
+        }
+        case "RootFilesystemSnapshotResponse": {
+            bare.writeU8(bc, 13);
+            writeRootFilesystemSnapshotResponse(bc, x.val);
+            break;
+        }
+        case "ProcessStartedResponse": {
+            bare.writeU8(bc, 14);
+            writeProcessStartedResponse(bc, x.val);
+            break;
+        }
+        case "StdinWrittenResponse": {
+            bare.writeU8(bc, 15);
+            writeStdinWrittenResponse(bc, x.val);
+            break;
+        }
+        case "StdinClosedResponse": {
+            bare.writeU8(bc, 16);
+            writeStdinClosedResponse(bc, x.val);
+            break;
+        }
+        case "ProcessKilledResponse": {
+            bare.writeU8(bc, 17);
+            writeProcessKilledResponse(bc, x.val);
+            break;
+        }
+        case "ProcessSnapshotResponse": {
+            bare.writeU8(bc, 18);
+            writeProcessSnapshotResponse(bc, x.val);
+            break;
+        }
+        case "ListenerSnapshotResponse": {
+            bare.writeU8(bc, 19);
+            writeListenerSnapshotResponse(bc, x.val);
+            break;
+        }
+        case "BoundUdpSnapshotResponse": {
+            bare.writeU8(bc, 20);
+            writeBoundUdpSnapshotResponse(bc, x.val);
+            break;
+        }
+        case "SignalStateResponse": {
+            bare.writeU8(bc, 21);
+            writeSignalStateResponse(bc, x.val);
+            break;
+        }
+        case "ZombieTimerCountResponse": {
+            bare.writeU8(bc, 22);
+            writeZombieTimerCountResponse(bc, x.val);
+            break;
+        }
+        case "FilesystemResultResponse": {
+            bare.writeU8(bc, 23);
+            writeFilesystemResultResponse(bc, x.val);
+            break;
+        }
+        case "PermissionDecisionResponse": {
+            bare.writeU8(bc, 24);
+            writePermissionDecisionResponse(bc, x.val);
+            break;
+        }
+        case "PersistenceStateResponse": {
+            bare.writeU8(bc, 25);
+            writePersistenceStateResponse(bc, x.val);
+            break;
+        }
+        case "PersistenceFlushedResponse": {
+            bare.writeU8(bc, 26);
+            writePersistenceFlushedResponse(bc, x.val);
+            break;
+        }
+        case "RejectedResponse": {
+            bare.writeU8(bc, 27);
+            writeRejectedResponse(bc, x.val);
+            break;
+        }
+        case "VmFetchResponse": {
+            bare.writeU8(bc, 28);
+            writeVmFetchResponse(bc, x.val);
+            break;
+        }
+        case "ExtEnvelope": {
+            bare.writeU8(bc, 29);
+            writeExtEnvelope(bc, x.val);
+            break;
+        }
+    }
+}
+export function readResponseFrame(bc) {
+    return {
+        schema: readProtocolSchema(bc),
+        requestId: readRequestId(bc),
+        ownership: readOwnershipScope(bc),
+        payload: readResponsePayload(bc),
+    };
+}
+export function writeResponseFrame(bc, x) {
+    writeProtocolSchema(bc, x.schema);
+    writeRequestId(bc, x.requestId);
+    writeOwnershipScope(bc, x.ownership);
+    writeResponsePayload(bc, x.payload);
+}
+export var VmLifecycleState;
+(function (VmLifecycleState) {
+    VmLifecycleState["Creating"] = "Creating";
+    VmLifecycleState["Ready"] = "Ready";
+    VmLifecycleState["Disposing"] = "Disposing";
+    VmLifecycleState["Disposed"] = "Disposed";
+    VmLifecycleState["Failed"] = "Failed";
+})(VmLifecycleState || (VmLifecycleState = {}));
+export function readVmLifecycleState(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return VmLifecycleState.Creating;
+        case 1:
+            return VmLifecycleState.Ready;
+        case 2:
+            return VmLifecycleState.Disposing;
+        case 3:
+            return VmLifecycleState.Disposed;
+        case 4:
+            return VmLifecycleState.Failed;
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeVmLifecycleState(bc, x) {
+    switch (x) {
+        case VmLifecycleState.Creating: {
+            bare.writeU8(bc, 0);
+            break;
+        }
+        case VmLifecycleState.Ready: {
+            bare.writeU8(bc, 1);
+            break;
+        }
+        case VmLifecycleState.Disposing: {
+            bare.writeU8(bc, 2);
+            break;
+        }
+        case VmLifecycleState.Disposed: {
+            bare.writeU8(bc, 3);
+            break;
+        }
+        case VmLifecycleState.Failed: {
+            bare.writeU8(bc, 4);
+            break;
+        }
+    }
+}
+export function readVmLifecycleEvent(bc) {
+    return {
+        state: readVmLifecycleState(bc),
+    };
+}
+export function writeVmLifecycleEvent(bc, x) {
+    writeVmLifecycleState(bc, x.state);
+}
+export var StreamChannel;
+(function (StreamChannel) {
+    StreamChannel["Stdout"] = "Stdout";
+    StreamChannel["Stderr"] = "Stderr";
+})(StreamChannel || (StreamChannel = {}));
+export function readStreamChannel(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return StreamChannel.Stdout;
+        case 1:
+            return StreamChannel.Stderr;
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeStreamChannel(bc, x) {
+    switch (x) {
+        case StreamChannel.Stdout: {
+            bare.writeU8(bc, 0);
+            break;
+        }
+        case StreamChannel.Stderr: {
+            bare.writeU8(bc, 1);
+            break;
+        }
+    }
+}
+export function readProcessOutputEvent(bc) {
+    return {
+        processId: bare.readString(bc),
+        channel: readStreamChannel(bc),
+        chunk: bare.readData(bc),
+    };
+}
+export function writeProcessOutputEvent(bc, x) {
+    bare.writeString(bc, x.processId);
+    writeStreamChannel(bc, x.channel);
+    bare.writeData(bc, x.chunk);
+}
+export function readProcessExitedEvent(bc) {
+    return {
+        processId: bare.readString(bc),
+        exitCode: bare.readI32(bc),
+    };
+}
+export function writeProcessExitedEvent(bc, x) {
+    bare.writeString(bc, x.processId);
+    bare.writeI32(bc, x.exitCode);
+}
+export function readStructuredEvent(bc) {
+    return {
+        name: bare.readString(bc),
+        detail: read1(bc),
+    };
+}
+export function writeStructuredEvent(bc, x) {
+    bare.writeString(bc, x.name);
+    write1(bc, x.detail);
+}
+export function readEventPayload(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return { tag: "VmLifecycleEvent", val: readVmLifecycleEvent(bc) };
+        case 1:
+            return { tag: "ProcessOutputEvent", val: readProcessOutputEvent(bc) };
+        case 2:
+            return { tag: "ProcessExitedEvent", val: readProcessExitedEvent(bc) };
+        case 3:
+            return { tag: "StructuredEvent", val: readStructuredEvent(bc) };
+        case 4:
+            return { tag: "ExtEnvelope", val: readExtEnvelope(bc) };
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeEventPayload(bc, x) {
+    switch (x.tag) {
+        case "VmLifecycleEvent": {
+            bare.writeU8(bc, 0);
+            writeVmLifecycleEvent(bc, x.val);
+            break;
+        }
+        case "ProcessOutputEvent": {
+            bare.writeU8(bc, 1);
+            writeProcessOutputEvent(bc, x.val);
+            break;
+        }
+        case "ProcessExitedEvent": {
+            bare.writeU8(bc, 2);
+            writeProcessExitedEvent(bc, x.val);
+            break;
+        }
+        case "StructuredEvent": {
+            bare.writeU8(bc, 3);
+            writeStructuredEvent(bc, x.val);
+            break;
+        }
+        case "ExtEnvelope": {
+            bare.writeU8(bc, 4);
+            writeExtEnvelope(bc, x.val);
+            break;
+        }
+    }
+}
+export function readEventFrame(bc) {
+    return {
+        schema: readProtocolSchema(bc),
+        ownership: readOwnershipScope(bc),
+        payload: readEventPayload(bc),
+    };
+}
+export function writeEventFrame(bc, x) {
+    writeProtocolSchema(bc, x.schema);
+    writeOwnershipScope(bc, x.ownership);
+    writeEventPayload(bc, x.payload);
+}
+export function readHostCallbackRequest(bc) {
+    return {
+        invocationId: bare.readString(bc),
+        callbackKey: bare.readString(bc),
+        input: readJsonUtf8(bc),
+        timeoutMs: bare.readU64(bc),
+    };
+}
+export function writeHostCallbackRequest(bc, x) {
+    bare.writeString(bc, x.invocationId);
+    bare.writeString(bc, x.callbackKey);
+    writeJsonUtf8(bc, x.input);
+    bare.writeU64(bc, x.timeoutMs);
+}
+export function readJsBridgeCallRequest(bc) {
+    return {
+        callId: bare.readString(bc),
+        mountId: bare.readString(bc),
+        operation: bare.readString(bc),
+        args: readJsonUtf8(bc),
+    };
+}
+export function writeJsBridgeCallRequest(bc, x) {
+    bare.writeString(bc, x.callId);
+    bare.writeString(bc, x.mountId);
+    bare.writeString(bc, x.operation);
+    writeJsonUtf8(bc, x.args);
+}
+export function readSidecarRequestPayload(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return { tag: "HostCallbackRequest", val: readHostCallbackRequest(bc) };
+        case 1:
+            return { tag: "JsBridgeCallRequest", val: readJsBridgeCallRequest(bc) };
+        case 2:
+            return { tag: "ExtEnvelope", val: readExtEnvelope(bc) };
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeSidecarRequestPayload(bc, x) {
+    switch (x.tag) {
+        case "HostCallbackRequest": {
+            bare.writeU8(bc, 0);
+            writeHostCallbackRequest(bc, x.val);
+            break;
+        }
+        case "JsBridgeCallRequest": {
+            bare.writeU8(bc, 1);
+            writeJsBridgeCallRequest(bc, x.val);
+            break;
+        }
+        case "ExtEnvelope": {
+            bare.writeU8(bc, 2);
+            writeExtEnvelope(bc, x.val);
+            break;
+        }
+    }
+}
+export function readSidecarRequestFrame(bc) {
+    return {
+        schema: readProtocolSchema(bc),
+        requestId: readRequestId(bc),
+        ownership: readOwnershipScope(bc),
+        payload: readSidecarRequestPayload(bc),
+    };
+}
+export function writeSidecarRequestFrame(bc, x) {
+    writeProtocolSchema(bc, x.schema);
+    writeRequestId(bc, x.requestId);
+    writeOwnershipScope(bc, x.ownership);
+    writeSidecarRequestPayload(bc, x.payload);
+}
+function read30(bc) {
+    return bare.readBool(bc) ? readJsonUtf8(bc) : null;
+}
+function write30(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        writeJsonUtf8(bc, x);
+    }
+}
+export function readHostCallbackResultResponse(bc) {
+    return {
+        invocationId: bare.readString(bc),
+        result: read30(bc),
+        error: read0(bc),
+    };
+}
+export function writeHostCallbackResultResponse(bc, x) {
+    bare.writeString(bc, x.invocationId);
+    write30(bc, x.result);
+    write0(bc, x.error);
+}
+export function readJsBridgeResultResponse(bc) {
+    return {
+        callId: bare.readString(bc),
+        result: read30(bc),
+        error: read0(bc),
+    };
+}
+export function writeJsBridgeResultResponse(bc, x) {
+    bare.writeString(bc, x.callId);
+    write30(bc, x.result);
+    write0(bc, x.error);
+}
+export function readSidecarResponsePayload(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return { tag: "HostCallbackResultResponse", val: readHostCallbackResultResponse(bc) };
+        case 1:
+            return { tag: "JsBridgeResultResponse", val: readJsBridgeResultResponse(bc) };
+        case 2:
+            return { tag: "ExtEnvelope", val: readExtEnvelope(bc) };
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeSidecarResponsePayload(bc, x) {
+    switch (x.tag) {
+        case "HostCallbackResultResponse": {
+            bare.writeU8(bc, 0);
+            writeHostCallbackResultResponse(bc, x.val);
+            break;
+        }
+        case "JsBridgeResultResponse": {
+            bare.writeU8(bc, 1);
+            writeJsBridgeResultResponse(bc, x.val);
+            break;
+        }
+        case "ExtEnvelope": {
+            bare.writeU8(bc, 2);
+            writeExtEnvelope(bc, x.val);
+            break;
+        }
+    }
+}
+export function readSidecarResponseFrame(bc) {
+    return {
+        schema: readProtocolSchema(bc),
+        requestId: readRequestId(bc),
+        ownership: readOwnershipScope(bc),
+        payload: readSidecarResponsePayload(bc),
+    };
+}
+export function writeSidecarResponseFrame(bc, x) {
+    writeProtocolSchema(bc, x.schema);
+    writeRequestId(bc, x.requestId);
+    writeOwnershipScope(bc, x.ownership);
+    writeSidecarResponsePayload(bc, x.payload);
+}
+export function readProtocolFrame(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return { tag: "RequestFrame", val: readRequestFrame(bc) };
+        case 1:
+            return { tag: "ResponseFrame", val: readResponseFrame(bc) };
+        case 2:
+            return { tag: "EventFrame", val: readEventFrame(bc) };
+        case 3:
+            return { tag: "SidecarRequestFrame", val: readSidecarRequestFrame(bc) };
+        case 4:
+            return { tag: "SidecarResponseFrame", val: readSidecarResponseFrame(bc) };
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeProtocolFrame(bc, x) {
+    switch (x.tag) {
+        case "RequestFrame": {
+            bare.writeU8(bc, 0);
+            writeRequestFrame(bc, x.val);
+            break;
+        }
+        case "ResponseFrame": {
+            bare.writeU8(bc, 1);
+            writeResponseFrame(bc, x.val);
+            break;
+        }
+        case "EventFrame": {
+            bare.writeU8(bc, 2);
+            writeEventFrame(bc, x.val);
+            break;
+        }
+        case "SidecarRequestFrame": {
+            bare.writeU8(bc, 3);
+            writeSidecarRequestFrame(bc, x.val);
+            break;
+        }
+        case "SidecarResponseFrame": {
+            bare.writeU8(bc, 4);
+            writeSidecarResponseFrame(bc, x.val);
+            break;
+        }
+    }
+}
+export function encodeProtocolFrame(x, config) {
+    const fullConfig = config != null ? bare.Config(config) : DEFAULT_CONFIG;
+    const bc = new bare.ByteCursor(new Uint8Array(fullConfig.initialBufferLength), fullConfig);
+    writeProtocolFrame(bc, x);
+    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+export function decodeProtocolFrame(bytes) {
+    const bc = new bare.ByteCursor(bytes, DEFAULT_CONFIG);
+    const result = readProtocolFrame(bc);
+    if (bc.offset < bc.view.byteLength) {
+        throw new bare.BareError(bc.offset, "remaining bytes");
+    }
+    return result;
+}