// @generated - run pnpm --dir packages/build-tools build:protocolimport * as bare from "@rivetkit/bare-ts" const DEFAULT_CONFIG = /* @__PURE__ */ bare.Config({}) export type i32 = numberexport type i64 = bigintexport type u16 = numberexport type u32 = numberexport type u64 = bigint export type JsonUtf8 = string export function readJsonUtf8(bc: bare.ByteCursor): JsonUtf8 {    return bare.readString(bc)} export function writeJsonUtf8(bc: bare.ByteCursor, x: JsonUtf8): void {    bare.writeString(bc, x)} export type ProtocolSchema = {    readonly name: string    readonly version: u16} export function readProtocolSchema(bc: bare.ByteCursor): ProtocolSchema {    return {        name: bare.readString(bc),        version: bare.readU16(bc),    }} export function writeProtocolSchema(bc: bare.ByteCursor, x: ProtocolSchema): void {    bare.writeString(bc, x.name)    bare.writeU16(bc, x.version)} export type RequestId = i64 export function readRequestId(bc: bare.ByteCursor): RequestId {    return bare.readI64(bc)} export function writeRequestId(bc: bare.ByteCursor, x: RequestId): void {    bare.writeI64(bc, x)} export type ExtEnvelope = {    readonly namespace: string    readonly payload: ArrayBuffer} export function readExtEnvelope(bc: bare.ByteCursor): ExtEnvelope {    return {        namespace: bare.readString(bc),        payload: bare.readData(bc),    }} export function writeExtEnvelope(bc: bare.ByteCursor, x: ExtEnvelope): void {    bare.writeString(bc, x.namespace)    bare.writeData(bc, x.payload)} export type ConnectionOwnership = {    readonly connectionId: string} export function readConnectionOwnership(bc: bare.ByteCursor): ConnectionOwnership {    return {        connectionId: bare.readString(bc),    }} export function writeConnectionOwnership(bc: bare.ByteCursor, x: ConnectionOwnership): void {    bare.writeString(bc, x.connectionId)} export type SessionOwnership = {    readonly connectionId: string    readonly sessionId: string} export function readSessionOwnership(bc: bare.ByteCursor): SessionOwnership {    return {        connectionId: bare.readString(bc),        sessionId: bare.readString(bc),    }} export function writeSessionOwnership(bc: bare.ByteCursor, x: SessionOwnership): void {    bare.writeString(bc, x.connectionId)    bare.writeString(bc, x.sessionId)} export type VmOwnership = {    readonly connectionId: string    readonly sessionId: string    readonly vmId: string} export function readVmOwnership(bc: bare.ByteCursor): VmOwnership {    return {        connectionId: bare.readString(bc),        sessionId: bare.readString(bc),        vmId: bare.readString(bc),    }} export function writeVmOwnership(bc: bare.ByteCursor, x: VmOwnership): void {    bare.writeString(bc, x.connectionId)    bare.writeString(bc, x.sessionId)    bare.writeString(bc, x.vmId)} export type OwnershipScope =    | { readonly tag: "ConnectionOwnership"; readonly val: ConnectionOwnership }    | { readonly tag: "SessionOwnership"; readonly val: SessionOwnership }    | { readonly tag: "VmOwnership"; readonly val: VmOwnership } export function readOwnershipScope(bc: bare.ByteCursor): OwnershipScope {    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: bare.ByteCursor, x: OwnershipScope): void {    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 type AuthenticateRequest = {    readonly clientName: string    readonly authToken: string    readonly protocolVersion: u16    readonly bridgeVersion: u32} export function readAuthenticateRequest(bc: bare.ByteCursor): AuthenticateRequest {    return {        clientName: bare.readString(bc),        authToken: bare.readString(bc),        protocolVersion: bare.readU16(bc),        bridgeVersion: bare.readU32(bc),    }} export function writeAuthenticateRequest(bc: bare.ByteCursor, x: AuthenticateRequest): void {    bare.writeString(bc, x.clientName)    bare.writeString(bc, x.authToken)    bare.writeU16(bc, x.protocolVersion)    bare.writeU32(bc, x.bridgeVersion)} function read0(bc: bare.ByteCursor): string | null {    return bare.readBool(bc) ? bare.readString(bc) : null} function write0(bc: bare.ByteCursor, x: string | null): void {    bare.writeBool(bc, x != null)    if (x != null) {        bare.writeString(bc, x)    }} export type SidecarPlacementShared = {    readonly pool: string | null} export function readSidecarPlacementShared(bc: bare.ByteCursor): SidecarPlacementShared {    return {        pool: read0(bc),    }} export function writeSidecarPlacementShared(bc: bare.ByteCursor, x: SidecarPlacementShared): void {    write0(bc, x.pool)} export type SidecarPlacementExplicit = {    readonly sidecarId: string} export function readSidecarPlacementExplicit(bc: bare.ByteCursor): SidecarPlacementExplicit {    return {        sidecarId: bare.readString(bc),    }} export function writeSidecarPlacementExplicit(bc: bare.ByteCursor, x: SidecarPlacementExplicit): void {    bare.writeString(bc, x.sidecarId)} export type SidecarPlacement =    | { readonly tag: "SidecarPlacementShared"; readonly val: SidecarPlacementShared }    | { readonly tag: "SidecarPlacementExplicit"; readonly val: SidecarPlacementExplicit } export function readSidecarPlacement(bc: bare.ByteCursor): SidecarPlacement {    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: bare.ByteCursor, x: SidecarPlacement): void {    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: bare.ByteCursor): ReadonlyMap<string, string> {    const len = bare.readUintSafe(bc)    const result = new Map<string, string>()    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: bare.ByteCursor, x: ReadonlyMap<string, string>): void {    bare.writeUintSafe(bc, x.size)    for (const kv of x) {        bare.writeString(bc, kv[0])        bare.writeString(bc, kv[1])    }} export type OpenSessionRequest = {    readonly placement: SidecarPlacement    readonly metadata: ReadonlyMap<string, string>} export function readOpenSessionRequest(bc: bare.ByteCursor): OpenSessionRequest {    return {        placement: readSidecarPlacement(bc),        metadata: read1(bc),    }} export function writeOpenSessionRequest(bc: bare.ByteCursor, x: OpenSessionRequest): void {    writeSidecarPlacement(bc, x.placement)    write1(bc, x.metadata)} export enum GuestRuntimeKind {    JavaScript = "JavaScript",    Python = "Python",    WebAssembly = "WebAssembly",} export function readGuestRuntimeKind(bc: bare.ByteCursor): GuestRuntimeKind {    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: bare.ByteCursor, x: GuestRuntimeKind): void {    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 enum RootFilesystemMode {    Ephemeral = "Ephemeral",    ReadOnly = "ReadOnly",} export function readRootFilesystemMode(bc: bare.ByteCursor): RootFilesystemMode {    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: bare.ByteCursor, x: RootFilesystemMode): void {    switch (x) {        case RootFilesystemMode.Ephemeral: {            bare.writeU8(bc, 0)            break        }        case RootFilesystemMode.ReadOnly: {            bare.writeU8(bc, 1)            break        }    }} export enum RootFilesystemEntryKind {    File = "File",    Directory = "Directory",    Symlink = "Symlink",} export function readRootFilesystemEntryKind(bc: bare.ByteCursor): RootFilesystemEntryKind {    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: bare.ByteCursor, x: RootFilesystemEntryKind): void {    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 enum RootFilesystemEntryEncoding {    UtF8 = "UtF8",    BasE64 = "BasE64",} export function readRootFilesystemEntryEncoding(bc: bare.ByteCursor): RootFilesystemEntryEncoding {    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: bare.ByteCursor, x: RootFilesystemEntryEncoding): void {    switch (x) {        case RootFilesystemEntryEncoding.UtF8: {            bare.writeU8(bc, 0)            break        }        case RootFilesystemEntryEncoding.BasE64: {            bare.writeU8(bc, 1)            break        }    }} function read2(bc: bare.ByteCursor): u32 | null {    return bare.readBool(bc) ? bare.readU32(bc) : null} function write2(bc: bare.ByteCursor, x: u32 | null): void {    bare.writeBool(bc, x != null)    if (x != null) {        bare.writeU32(bc, x)    }} function read3(bc: bare.ByteCursor): RootFilesystemEntryEncoding | null {    return bare.readBool(bc) ? readRootFilesystemEntryEncoding(bc) : null} function write3(bc: bare.ByteCursor, x: RootFilesystemEntryEncoding | null): void {    bare.writeBool(bc, x != null)    if (x != null) {        writeRootFilesystemEntryEncoding(bc, x)    }} export type RootFilesystemEntry = {    readonly path: string    readonly kind: RootFilesystemEntryKind    readonly mode: u32 | null    readonly uid: u32 | null    readonly gid: u32 | null    readonly content: string | null    readonly encoding: RootFilesystemEntryEncoding | null    readonly target: string | null    readonly executable: boolean} export function readRootFilesystemEntry(bc: bare.ByteCursor): RootFilesystemEntry {    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: bare.ByteCursor, x: RootFilesystemEntry): void {    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)} 

Lines 1–500 of 4599. Load more