@rivet-dev/agentos-runtime-core 0.0.0-agent-acp-codex-session-benchmark.62b1f46

package/dist/generated-protocol.d.ts

@@ -0,0 +1,1452 @@
+import * as bare from "@rivetkit/bare-ts";
+export type i32 = number;
+export type i64 = bigint;
+export type u16 = number;
+export type u32 = number;
+export type u64 = bigint;
+export type JsonUtf8 = string;
+export declare function readJsonUtf8(bc: bare.ByteCursor): JsonUtf8;
+export declare function writeJsonUtf8(bc: bare.ByteCursor, x: JsonUtf8): void;
+export type ProtocolSchema = {
+    readonly name: string;
+    readonly version: u16;
+};
+export declare function readProtocolSchema(bc: bare.ByteCursor): ProtocolSchema;
+export declare function writeProtocolSchema(bc: bare.ByteCursor, x: ProtocolSchema): void;
+export type RequestId = i64;
+export declare function readRequestId(bc: bare.ByteCursor): RequestId;
+export declare function writeRequestId(bc: bare.ByteCursor, x: RequestId): void;
+export type ExtEnvelope = {
+    readonly namespace: string;
+    readonly payload: ArrayBuffer;
+};
+export declare function readExtEnvelope(bc: bare.ByteCursor): ExtEnvelope;
+export declare function writeExtEnvelope(bc: bare.ByteCursor, x: ExtEnvelope): void;
+export type ConnectionOwnership = {
+    readonly connectionId: string;
+};
+export declare function readConnectionOwnership(bc: bare.ByteCursor): ConnectionOwnership;
+export declare function writeConnectionOwnership(bc: bare.ByteCursor, x: ConnectionOwnership): void;
+export type SessionOwnership = {
+    readonly connectionId: string;
+    readonly sessionId: string;
+};
+export declare function readSessionOwnership(bc: bare.ByteCursor): SessionOwnership;
+export declare function writeSessionOwnership(bc: bare.ByteCursor, x: SessionOwnership): void;
+export type VmOwnership = {
+    readonly connectionId: string;
+    readonly sessionId: string;
+    readonly vmId: string;
+};
+export declare function readVmOwnership(bc: bare.ByteCursor): VmOwnership;
+export declare function writeVmOwnership(bc: bare.ByteCursor, x: VmOwnership): void;
+export type OwnershipScope = {
+    readonly tag: "ConnectionOwnership";
+    readonly val: ConnectionOwnership;
+} | {
+    readonly tag: "SessionOwnership";
+    readonly val: SessionOwnership;
+} | {
+    readonly tag: "VmOwnership";
+    readonly val: VmOwnership;
+};
+export declare function readOwnershipScope(bc: bare.ByteCursor): OwnershipScope;
+export declare function writeOwnershipScope(bc: bare.ByteCursor, x: OwnershipScope): void;
+export type AuthenticateRequest = {
+    readonly clientName: string;
+    readonly authToken: string;
+    readonly protocolVersion: u16;
+    readonly bridgeVersion: u32;
+};
+export declare function readAuthenticateRequest(bc: bare.ByteCursor): AuthenticateRequest;
+export declare function writeAuthenticateRequest(bc: bare.ByteCursor, x: AuthenticateRequest): void;
+export type SidecarPlacementShared = {
+    readonly pool: string | null;
+};
+export declare function readSidecarPlacementShared(bc: bare.ByteCursor): SidecarPlacementShared;
+export declare function writeSidecarPlacementShared(bc: bare.ByteCursor, x: SidecarPlacementShared): void;
+export type SidecarPlacementExplicit = {
+    readonly sidecarId: string;
+};
+export declare function readSidecarPlacementExplicit(bc: bare.ByteCursor): SidecarPlacementExplicit;
+export declare function writeSidecarPlacementExplicit(bc: bare.ByteCursor, x: SidecarPlacementExplicit): void;
+export type SidecarPlacement = {
+    readonly tag: "SidecarPlacementShared";
+    readonly val: SidecarPlacementShared;
+} | {
+    readonly tag: "SidecarPlacementExplicit";
+    readonly val: SidecarPlacementExplicit;
+};
+export declare function readSidecarPlacement(bc: bare.ByteCursor): SidecarPlacement;
+export declare function writeSidecarPlacement(bc: bare.ByteCursor, x: SidecarPlacement): void;
+export type OpenSessionRequest = {
+    readonly placement: SidecarPlacement;
+};
+export declare function readOpenSessionRequest(bc: bare.ByteCursor): OpenSessionRequest;
+export declare function writeOpenSessionRequest(bc: bare.ByteCursor, x: OpenSessionRequest): void;
+export type CloseSessionRequest = {
+    readonly sessionId: string;
+};
+export declare function readCloseSessionRequest(bc: bare.ByteCursor): CloseSessionRequest;
+export declare function writeCloseSessionRequest(bc: bare.ByteCursor, x: CloseSessionRequest): void;
+export declare enum GuestRuntimeKind {
+    JavaScript = "JavaScript",
+    Python = "Python",
+    WebAssembly = "WebAssembly"
+}
+export declare function readGuestRuntimeKind(bc: bare.ByteCursor): GuestRuntimeKind;
+export declare function writeGuestRuntimeKind(bc: bare.ByteCursor, x: GuestRuntimeKind): void;
+export declare enum RootFilesystemMode {
+    Ephemeral = "Ephemeral",
+    ReadOnly = "ReadOnly"
+}
+export declare function readRootFilesystemMode(bc: bare.ByteCursor): RootFilesystemMode;
+export declare function writeRootFilesystemMode(bc: bare.ByteCursor, x: RootFilesystemMode): void;
+export declare enum RootFilesystemEntryKind {
+    File = "File",
+    Directory = "Directory",
+    Symlink = "Symlink"
+}
+export declare function readRootFilesystemEntryKind(bc: bare.ByteCursor): RootFilesystemEntryKind;
+export declare function writeRootFilesystemEntryKind(bc: bare.ByteCursor, x: RootFilesystemEntryKind): void;
+export declare enum RootFilesystemEntryEncoding {
+    UtF8 = "UtF8",
+    BasE64 = "BasE64"
+}
+export declare function readRootFilesystemEntryEncoding(bc: bare.ByteCursor): RootFilesystemEntryEncoding;
+export declare function writeRootFilesystemEntryEncoding(bc: bare.ByteCursor, x: RootFilesystemEntryEncoding): void;
+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 declare function readRootFilesystemEntry(bc: bare.ByteCursor): RootFilesystemEntry;
+export declare function writeRootFilesystemEntry(bc: bare.ByteCursor, x: RootFilesystemEntry): void;
+export type SnapshotRootFilesystemLower = {
+    readonly entries: readonly RootFilesystemEntry[];
+};
+export declare function readSnapshotRootFilesystemLower(bc: bare.ByteCursor): SnapshotRootFilesystemLower;
+export declare function writeSnapshotRootFilesystemLower(bc: bare.ByteCursor, x: SnapshotRootFilesystemLower): void;
+export type BundledBaseFilesystemLower = null;
+export type RootFilesystemLowerDescriptor = {
+    readonly tag: "SnapshotRootFilesystemLower";
+    readonly val: SnapshotRootFilesystemLower;
+} | {
+    readonly tag: "BundledBaseFilesystemLower";
+    readonly val: BundledBaseFilesystemLower;
+};
+export declare function readRootFilesystemLowerDescriptor(bc: bare.ByteCursor): RootFilesystemLowerDescriptor;
+export declare function writeRootFilesystemLowerDescriptor(bc: bare.ByteCursor, x: RootFilesystemLowerDescriptor): void;
+export type RootFilesystemDescriptor = {
+    readonly mode: RootFilesystemMode;
+    readonly disableDefaultBaseLayer: boolean;
+    readonly lowers: readonly RootFilesystemLowerDescriptor[];
+    readonly bootstrapEntries: readonly RootFilesystemEntry[];
+};
+export declare function readRootFilesystemDescriptor(bc: bare.ByteCursor): RootFilesystemDescriptor;
+export declare function writeRootFilesystemDescriptor(bc: bare.ByteCursor, x: RootFilesystemDescriptor): void;
+export declare function encodeRootFilesystemDescriptor(x: RootFilesystemDescriptor, config?: Partial<bare.Config>): Uint8Array;
+export declare function decodeRootFilesystemDescriptor(bytes: Uint8Array): RootFilesystemDescriptor;
+export declare enum PermissionMode {
+    Allow = "Allow",
+    Ask = "Ask",
+    Deny = "Deny"
+}
+export declare function readPermissionMode(bc: bare.ByteCursor): PermissionMode;
+export declare function writePermissionMode(bc: bare.ByteCursor, x: PermissionMode): void;
+export type FsPermissionRule = {
+    readonly mode: PermissionMode;
+    readonly operations: readonly string[] | null;
+    readonly paths: readonly string[] | null;
+};
+export declare function readFsPermissionRule(bc: bare.ByteCursor): FsPermissionRule;
+export declare function writeFsPermissionRule(bc: bare.ByteCursor, x: FsPermissionRule): void;
+export type FsPermissionRuleSet = {
+    readonly default: PermissionMode | null;
+    readonly rules: readonly FsPermissionRule[];
+};
+export declare function readFsPermissionRuleSet(bc: bare.ByteCursor): FsPermissionRuleSet;
+export declare function writeFsPermissionRuleSet(bc: bare.ByteCursor, x: FsPermissionRuleSet): void;
+export type FsPermissionScope = {
+    readonly tag: "PermissionMode";
+    readonly val: PermissionMode;
+} | {
+    readonly tag: "FsPermissionRuleSet";
+    readonly val: FsPermissionRuleSet;
+};
+export declare function readFsPermissionScope(bc: bare.ByteCursor): FsPermissionScope;
+export declare function writeFsPermissionScope(bc: bare.ByteCursor, x: FsPermissionScope): void;
+export type PatternPermissionRule = {
+    readonly mode: PermissionMode;
+    readonly operations: readonly string[] | null;
+    readonly patterns: readonly string[] | null;
+};
+export declare function readPatternPermissionRule(bc: bare.ByteCursor): PatternPermissionRule;
+export declare function writePatternPermissionRule(bc: bare.ByteCursor, x: PatternPermissionRule): void;
+export type PatternPermissionRuleSet = {
+    readonly default: PermissionMode | null;
+    readonly rules: readonly PatternPermissionRule[];
+};
+export declare function readPatternPermissionRuleSet(bc: bare.ByteCursor): PatternPermissionRuleSet;
+export declare function writePatternPermissionRuleSet(bc: bare.ByteCursor, x: PatternPermissionRuleSet): void;
+export type PatternPermissionScope = {
+    readonly tag: "PermissionMode";
+    readonly val: PermissionMode;
+} | {
+    readonly tag: "PatternPermissionRuleSet";
+    readonly val: PatternPermissionRuleSet;
+};
+export declare function readPatternPermissionScope(bc: bare.ByteCursor): PatternPermissionScope;
+export declare function writePatternPermissionScope(bc: bare.ByteCursor, x: PatternPermissionScope): void;
+export type PermissionsPolicy = {
+    readonly fs: FsPermissionScope | null;
+    readonly network: PatternPermissionScope | null;
+    readonly childProcess: PatternPermissionScope | null;
+    readonly process: PatternPermissionScope | null;
+    readonly env: PatternPermissionScope | null;
+    readonly binding: PatternPermissionScope | null;
+};
+export declare function readPermissionsPolicy(bc: bare.ByteCursor): PermissionsPolicy;
+export declare function writePermissionsPolicy(bc: bare.ByteCursor, x: PermissionsPolicy): void;
+export type CreateVmRequest = {
+    readonly runtime: GuestRuntimeKind;
+    readonly config: JsonUtf8;
+};
+export declare function readCreateVmRequest(bc: bare.ByteCursor): CreateVmRequest;
+export declare function writeCreateVmRequest(bc: bare.ByteCursor, x: CreateVmRequest): void;
+export declare enum DisposeReason {
+    Requested = "Requested",
+    ConnectionClosed = "ConnectionClosed",
+    HostShutdown = "HostShutdown"
+}
+export declare function readDisposeReason(bc: bare.ByteCursor): DisposeReason;
+export declare function writeDisposeReason(bc: bare.ByteCursor, x: DisposeReason): void;
+export type DisposeVmRequest = {
+    readonly reason: DisposeReason;
+};
+export declare function readDisposeVmRequest(bc: bare.ByteCursor): DisposeVmRequest;
+export declare function writeDisposeVmRequest(bc: bare.ByteCursor, x: DisposeVmRequest): void;
+export type BootstrapRootFilesystemRequest = {
+    readonly entries: readonly RootFilesystemEntry[];
+};
+export declare function readBootstrapRootFilesystemRequest(bc: bare.ByteCursor): BootstrapRootFilesystemRequest;
+export declare function writeBootstrapRootFilesystemRequest(bc: bare.ByteCursor, x: BootstrapRootFilesystemRequest): void;
+export type MountPluginDescriptor = {
+    readonly id: string;
+    readonly config: JsonUtf8 | null;
+};
+export declare function readMountPluginDescriptor(bc: bare.ByteCursor): MountPluginDescriptor;
+export declare function writeMountPluginDescriptor(bc: bare.ByteCursor, x: MountPluginDescriptor): void;
+export type MountDescriptor = {
+    readonly guestPath: string;
+    readonly readOnly: boolean | null;
+    readonly plugin: MountPluginDescriptor;
+};
+export declare function readMountDescriptor(bc: bare.ByteCursor): MountDescriptor;
+export declare function writeMountDescriptor(bc: bare.ByteCursor, x: MountDescriptor): void;
+export declare enum WasmPermissionTier {
+    Full = "Full",
+    ReadWrite = "ReadWrite",
+    ReadOnly = "ReadOnly",
+    Isolated = "Isolated"
+}
+export declare function readWasmPermissionTier(bc: bare.ByteCursor): WasmPermissionTier;
+export declare function writeWasmPermissionTier(bc: bare.ByteCursor, x: WasmPermissionTier): void;
+/**
+ * Native sidecars accept a trusted host path. It normally names the packed
+ * `.aospkg`; a directory is accepted only for local transition fixtures.
+ */
+export type PackagePath = {
+    readonly path: string;
+};
+export declare function readPackagePath(bc: bare.ByteCursor): PackagePath;
+export declare function writePackagePath(bc: bare.ByteCursor, x: PackagePath): void;
+/**
+ * Browser sidecars cannot dereference host paths. Their package manager forwards
+ * the complete opaque `.aospkg` bytes; only the sidecar decodes metadata.
+ */
+export type PackageInline = {
+    readonly content: ArrayBuffer;
+};
+export declare function readPackageInline(bc: bare.ByteCursor): PackageInline;
+export declare function writePackageInline(bc: bare.ByteCursor, x: PackageInline): void;
+/**
+ * agentOS package input. The sidecar reads the vbare manifest and mount index,
+ * projects the package read-only under `<packagesMountAt>/pkgs/<name>/<version>`,
+ * and links its commands onto $PATH. Clients never send parsed package metadata.
+ */
+export type PackageDescriptor = {
+    readonly tag: "PackagePath";
+    readonly val: PackagePath;
+} | {
+    readonly tag: "PackageInline";
+    readonly val: PackageInline;
+};
+export declare function readPackageDescriptor(bc: bare.ByteCursor): PackageDescriptor;
+export declare function writePackageDescriptor(bc: bare.ByteCursor, x: PackageDescriptor): void;
+export type AgentosProjectedAgent = {
+    readonly id: string;
+    readonly acpEntrypoint: string;
+    readonly adapterEntrypoint: string;
+};
+export declare function readAgentosProjectedAgent(bc: bare.ByteCursor): AgentosProjectedAgent;
+export declare function writeAgentosProjectedAgent(bc: bare.ByteCursor, x: AgentosProjectedAgent): void;
+export type LinkPackageRequest = {
+    readonly package: PackageDescriptor;
+};
+export declare function readLinkPackageRequest(bc: bare.ByteCursor): LinkPackageRequest;
+export declare function writeLinkPackageRequest(bc: bare.ByteCursor, x: LinkPackageRequest): void;
+export type PackageCommands = {
+    readonly packageName: string;
+    readonly commands: readonly string[];
+};
+export declare function readPackageCommands(bc: bare.ByteCursor): PackageCommands;
+export declare function writePackageCommands(bc: bare.ByteCursor, x: PackageCommands): void;
+export type ProvidedCommandsRequest = null;
+export type ProvidedCommandsResponse = {
+    readonly packages: readonly PackageCommands[];
+};
+export declare function readProvidedCommandsResponse(bc: bare.ByteCursor): ProvidedCommandsResponse;
+export declare function writeProvidedCommandsResponse(bc: bare.ByteCursor, x: ProvidedCommandsResponse): void;
+export type ProjectedCommand = {
+    readonly name: string;
+    readonly guestPath: string;
+};
+export declare function readProjectedCommand(bc: bare.ByteCursor): ProjectedCommand;
+export declare function writeProjectedCommand(bc: bare.ByteCursor, x: ProjectedCommand): void;
+export type PackageLinkedResponse = {
+    readonly projectedCommands: readonly ProjectedCommand[];
+    readonly agents: readonly AgentosProjectedAgent[];
+};
+export declare function readPackageLinkedResponse(bc: bare.ByteCursor): PackageLinkedResponse;
+export declare function writePackageLinkedResponse(bc: bare.ByteCursor, x: PackageLinkedResponse): void;
+export type ConfigureVmRequest = {
+    readonly mounts: readonly MountDescriptor[] | null;
+    readonly permissions: PermissionsPolicy | null;
+    readonly commandPermissions: ReadonlyMap<string, WasmPermissionTier> | null;
+    readonly loopbackExemptPorts: Uint16Array | null;
+    readonly packages: readonly PackageDescriptor[] | null;
+    readonly packagesMountAt: string | null;
+};
+export declare function readConfigureVmRequest(bc: bare.ByteCursor): ConfigureVmRequest;
+export declare function writeConfigureVmRequest(bc: bare.ByteCursor, x: ConfigureVmRequest): void;
+export type RegisteredHostCallbackExample = {
+    readonly description: string;
+    readonly input: JsonUtf8;
+};
+export declare function readRegisteredHostCallbackExample(bc: bare.ByteCursor): RegisteredHostCallbackExample;
+export declare function writeRegisteredHostCallbackExample(bc: bare.ByteCursor, x: RegisteredHostCallbackExample): void;
+export type RegisteredHostCallbackDefinition = {
+    readonly description: string;
+    readonly inputSchema: JsonUtf8;
+    readonly timeoutMs: u64 | null;
+    readonly examples: readonly RegisteredHostCallbackExample[];
+};
+export declare function readRegisteredHostCallbackDefinition(bc: bare.ByteCursor): RegisteredHostCallbackDefinition;
+export declare function writeRegisteredHostCallbackDefinition(bc: bare.ByteCursor, x: RegisteredHostCallbackDefinition): void;
+export type RegisterHostCallbacksRequest = {
+    readonly name: string;
+    readonly description: string;
+    readonly callbacks: ReadonlyMap<string, RegisteredHostCallbackDefinition>;
+};
+export declare function readRegisterHostCallbacksRequest(bc: bare.ByteCursor): RegisterHostCallbacksRequest;
+export declare function writeRegisterHostCallbacksRequest(bc: bare.ByteCursor, x: RegisterHostCallbacksRequest): void;
+/**
+ * Atomic AgentOS VM initialization. The sidecar creates the VM, reaches ready,
+ * applies explicit mounts/packages, and registers host callback metadata before
+ * returning one resolved VM view. Omitted collections remain sidecar defaults.
+ */
+export type InitializeVmRequest = {
+    readonly runtime: GuestRuntimeKind;
+    readonly config: JsonUtf8;
+    readonly mounts: readonly MountDescriptor[] | null;
+    readonly packages: readonly PackageDescriptor[] | null;
+    readonly packagesMountAt: string | null;
+    readonly hostCallbacks: readonly RegisterHostCallbacksRequest[] | null;
+};
+export declare function readInitializeVmRequest(bc: bare.ByteCursor): InitializeVmRequest;
+export declare function writeInitializeVmRequest(bc: bare.ByteCursor, x: InitializeVmRequest): void;
+export type CreateLayerRequest = null;
+export type SealLayerRequest = {
+    readonly layerId: string;
+};
+export declare function readSealLayerRequest(bc: bare.ByteCursor): SealLayerRequest;
+export declare function writeSealLayerRequest(bc: bare.ByteCursor, x: SealLayerRequest): void;
+export type ImportSnapshotRequest = {
+    readonly entries: readonly RootFilesystemEntry[];
+};
+export declare function readImportSnapshotRequest(bc: bare.ByteCursor): ImportSnapshotRequest;
+export declare function writeImportSnapshotRequest(bc: bare.ByteCursor, x: ImportSnapshotRequest): void;
+export type ExportSnapshotRequest = {
+    readonly layerId: string;
+};
+export declare function readExportSnapshotRequest(bc: bare.ByteCursor): ExportSnapshotRequest;
+export declare function writeExportSnapshotRequest(bc: bare.ByteCursor, x: ExportSnapshotRequest): void;
+export type CreateOverlayRequest = {
+    readonly mode: RootFilesystemMode | null;
+    readonly upperLayerId: string | null;
+    readonly lowerLayerIds: readonly string[];
+};
+export declare function readCreateOverlayRequest(bc: bare.ByteCursor): CreateOverlayRequest;
+export declare function writeCreateOverlayRequest(bc: bare.ByteCursor, x: CreateOverlayRequest): void;
+export declare enum GuestFilesystemOperation {
+    ReadFile = "ReadFile",
+    WriteFile = "WriteFile",
+    CreateDir = "CreateDir",
+    Mkdir = "Mkdir",
+    Exists = "Exists",
+    Stat = "Stat",
+    Lstat = "Lstat",
+    ReadDir = "ReadDir",
+    ReadDirRecursive = "ReadDirRecursive",
+    RemoveFile = "RemoveFile",
+    RemoveDir = "RemoveDir",
+    Remove = "Remove",
+    Copy = "Copy",
+    Move = "Move",
+    Rename = "Rename",
+    Realpath = "Realpath",
+    Symlink = "Symlink",
+    ReadLink = "ReadLink",
+    Link = "Link",
+    Chmod = "Chmod",
+    Chown = "Chown",
+    Utimes = "Utimes",
+    Truncate = "Truncate",
+    Pread = "Pread",
+    Pwrite = "Pwrite"
+}
+export declare function readGuestFilesystemOperation(bc: bare.ByteCursor): GuestFilesystemOperation;
+export declare function writeGuestFilesystemOperation(bc: bare.ByteCursor, x: GuestFilesystemOperation): void;
+export type GuestFilesystemCallRequest = {
+    readonly operation: GuestFilesystemOperation;
+    readonly path: string;
+    readonly destinationPath: string | null;
+    readonly target: string | null;
+    readonly content: string | null;
+    readonly encoding: RootFilesystemEntryEncoding | null;
+    readonly recursive: boolean | null;
+    readonly maxDepth: u32 | null;
+    readonly mode: u32 | null;
+    readonly uid: u32 | null;
+    readonly gid: u32 | null;
+    readonly atimeMs: u64 | null;
+    readonly mtimeMs: u64 | null;
+    readonly len: u64 | null;
+    readonly offset: u64 | null;
+};
+export declare function readGuestFilesystemCallRequest(bc: bare.ByteCursor): GuestFilesystemCallRequest;
+export declare function writeGuestFilesystemCallRequest(bc: bare.ByteCursor, x: GuestFilesystemCallRequest): void;
+export type GuestKernelCallRequest = {
+    readonly executionId: string;
+    readonly operation: string;
+    readonly payload: ArrayBuffer;
+};
+export declare function readGuestKernelCallRequest(bc: bare.ByteCursor): GuestKernelCallRequest;
+export declare function writeGuestKernelCallRequest(bc: bare.ByteCursor, x: GuestKernelCallRequest): void;
+export type SnapshotRootFilesystemRequest = null;
+export type PtyOptions = {
+    readonly cols: u16 | null;
+    readonly rows: u16 | null;
+};
+export declare function readPtyOptions(bc: bare.ByteCursor): PtyOptions;
+export declare function writePtyOptions(bc: bare.ByteCursor, x: PtyOptions): void;
+export type ExecuteRequest = {
+    readonly processId: string | null;
+    readonly command: string | null;
+    readonly shellCommand: string | null;
+    readonly runtime: GuestRuntimeKind | null;
+    readonly entrypoint: string | null;
+    readonly args: readonly string[];
+    readonly env: ReadonlyMap<string, string> | null;
+    readonly cwd: string | null;
+    readonly wasmPermissionTier: WasmPermissionTier | null;
+    readonly pty: PtyOptions | null;
+    readonly keepStdinOpen: boolean | null;
+    readonly timeoutMs: u64 | null;
+    readonly captureOutput: boolean | null;
+};
+export declare function readExecuteRequest(bc: bare.ByteCursor): ExecuteRequest;
+export declare function writeExecuteRequest(bc: bare.ByteCursor, x: ExecuteRequest): void;
+export type WriteStdinRequest = {
+    readonly processId: string;
+    readonly chunk: ArrayBuffer;
+};
+export declare function readWriteStdinRequest(bc: bare.ByteCursor): WriteStdinRequest;
+export declare function writeWriteStdinRequest(bc: bare.ByteCursor, x: WriteStdinRequest): void;
+export type ResizePtyRequest = {
+    readonly processId: string;
+    readonly cols: u16;
+    readonly rows: u16;
+};
+export declare function readResizePtyRequest(bc: bare.ByteCursor): ResizePtyRequest;
+export declare function writeResizePtyRequest(bc: bare.ByteCursor, x: ResizePtyRequest): void;
+export type CloseStdinRequest = {
+    readonly processId: string;
+};
+export declare function readCloseStdinRequest(bc: bare.ByteCursor): CloseStdinRequest;
+export declare function writeCloseStdinRequest(bc: bare.ByteCursor, x: CloseStdinRequest): void;
+export type KillProcessRequest = {
+    readonly processId: string;
+    readonly signal: string;
+};
+export declare function readKillProcessRequest(bc: bare.ByteCursor): KillProcessRequest;
+export declare function writeKillProcessRequest(bc: bare.ByteCursor, x: KillProcessRequest): void;
+export type GetProcessSnapshotRequest = null;
+export type GetResourceSnapshotRequest = null;
+export type FindListenerRequest = {
+    readonly host: string | null;
+    readonly port: u16 | null;
+    readonly path: string | null;
+};
+export declare function readFindListenerRequest(bc: bare.ByteCursor): FindListenerRequest;
+export declare function writeFindListenerRequest(bc: bare.ByteCursor, x: FindListenerRequest): void;
+export type FindBoundUdpRequest = {
+    readonly host: string | null;
+    readonly port: u16 | null;
+};
+export declare function readFindBoundUdpRequest(bc: bare.ByteCursor): FindBoundUdpRequest;
+export declare function writeFindBoundUdpRequest(bc: bare.ByteCursor, x: FindBoundUdpRequest): void;
+export type GetSignalStateRequest = {
+    readonly processId: string;
+};
+export declare function readGetSignalStateRequest(bc: bare.ByteCursor): GetSignalStateRequest;
+export declare function writeGetSignalStateRequest(bc: bare.ByteCursor, x: GetSignalStateRequest): void;
+export type GetZombieTimerCountRequest = null;
+export declare enum FilesystemOperation {
+    Read = "Read",
+    Write = "Write",
+    Stat = "Stat",
+    ReadDir = "ReadDir",
+    Mkdir = "Mkdir",
+    Remove = "Remove",
+    Rename = "Rename"
+}
+export declare function readFilesystemOperation(bc: bare.ByteCursor): FilesystemOperation;
+export declare function writeFilesystemOperation(bc: bare.ByteCursor, x: FilesystemOperation): void;
+export type HostFilesystemCallRequest = {
+    readonly operation: FilesystemOperation;
+    readonly path: string;
+    readonly payloadSizeBytes: u64;
+};
+export declare function readHostFilesystemCallRequest(bc: bare.ByteCursor): HostFilesystemCallRequest;
+export declare function writeHostFilesystemCallRequest(bc: bare.ByteCursor, x: HostFilesystemCallRequest): void;
+export type PersistenceLoadRequest = {
+    readonly key: string;
+};
+export declare function readPersistenceLoadRequest(bc: bare.ByteCursor): PersistenceLoadRequest;
+export declare function writePersistenceLoadRequest(bc: bare.ByteCursor, x: PersistenceLoadRequest): void;
+export type PersistenceFlushRequest = {
+    readonly key: string;
+    readonly payloadSizeBytes: u64;
+};
+export declare function readPersistenceFlushRequest(bc: bare.ByteCursor): PersistenceFlushRequest;
+export declare function writePersistenceFlushRequest(bc: bare.ByteCursor, x: PersistenceFlushRequest): void;
+export type VmFetchRequest = {
+    readonly port: u16;
+    readonly method: string;
+    readonly path: string;
+    readonly headersJson: string;
+    readonly body: string | null;
+};
+export declare function readVmFetchRequest(bc: bare.ByteCursor): VmFetchRequest;
+export declare function writeVmFetchRequest(bc: bare.ByteCursor, x: VmFetchRequest): void;
+export declare enum CronOverlap {
+    Allow = "Allow",
+    Skip = "Skip",
+    Queue = "Queue"
+}
+export declare function readCronOverlap(bc: bare.ByteCursor): CronOverlap;
+export declare function writeCronOverlap(bc: bare.ByteCursor, x: CronOverlap): void;
+/**
+ * `action` is an opaque, client-authored JSON value. The sidecar owns schedule
+ * parsing and lifecycle state; the client only retains/runs host resources that
+ * cannot cross the protocol (notably callback closures).
+ */
+export type ScheduleCronRequest = {
+    readonly id: string | null;
+    readonly schedule: string;
+    readonly action: JsonUtf8;
+    readonly overlap: CronOverlap | null;
+};
+export declare function readScheduleCronRequest(bc: bare.ByteCursor): ScheduleCronRequest;
+export declare function writeScheduleCronRequest(bc: bare.ByteCursor, x: ScheduleCronRequest): void;
+export type ListCronJobsRequest = null;
+export type CancelCronJobRequest = {
+    readonly id: string;
+};
+export declare function readCancelCronJobRequest(bc: bare.ByteCursor): CancelCronJobRequest;
+export declare function writeCancelCronJobRequest(bc: bare.ByteCursor, x: CancelCronJobRequest): void;
+export type WakeCronRequest = {
+    readonly generation: u64;
+};
+export declare function readWakeCronRequest(bc: bare.ByteCursor): WakeCronRequest;
+export declare function writeWakeCronRequest(bc: bare.ByteCursor, x: WakeCronRequest): void;
+export type CompleteCronRunRequest = {
+    readonly runId: string;
+    readonly error: string | null;
+};
+export declare function readCompleteCronRunRequest(bc: bare.ByteCursor): CompleteCronRunRequest;
+export declare function writeCompleteCronRunRequest(bc: bare.ByteCursor, x: CompleteCronRunRequest): void;
+/**
+ * Opaque sidecar-owned persistence. Hosts may store and return this value but
+ * must not inspect, merge, or manufacture it.
+ */
+export type ExportCronStateRequest = null;
+export type ImportCronStateRequest = {
+    readonly state: JsonUtf8;
+};
+export declare function readImportCronStateRequest(bc: bare.ByteCursor): ImportCronStateRequest;
+export declare function writeImportCronStateRequest(bc: bare.ByteCursor, x: ImportCronStateRequest): void;
+export type RequestPayload = {
+    readonly tag: "AuthenticateRequest";
+    readonly val: AuthenticateRequest;
+} | {
+    readonly tag: "OpenSessionRequest";
+    readonly val: OpenSessionRequest;
+} | {
+    readonly tag: "CreateVmRequest";
+    readonly val: CreateVmRequest;
+} | {
+    readonly tag: "DisposeVmRequest";
+    readonly val: DisposeVmRequest;
+} | {
+    readonly tag: "BootstrapRootFilesystemRequest";
+    readonly val: BootstrapRootFilesystemRequest;
+} | {
+    readonly tag: "ConfigureVmRequest";
+    readonly val: ConfigureVmRequest;
+} | {
+    readonly tag: "RegisterHostCallbacksRequest";
+    readonly val: RegisterHostCallbacksRequest;
+} | {
+    readonly tag: "CreateLayerRequest";
+    readonly val: CreateLayerRequest;
+} | {
+    readonly tag: "SealLayerRequest";
+    readonly val: SealLayerRequest;
+} | {
+    readonly tag: "ImportSnapshotRequest";
+    readonly val: ImportSnapshotRequest;
+} | {
+    readonly tag: "ExportSnapshotRequest";
+    readonly val: ExportSnapshotRequest;
+} | {
+    readonly tag: "CreateOverlayRequest";
+    readonly val: CreateOverlayRequest;
+} | {
+    readonly tag: "GuestFilesystemCallRequest";
+    readonly val: GuestFilesystemCallRequest;
+} | {
+    readonly tag: "SnapshotRootFilesystemRequest";
+    readonly val: SnapshotRootFilesystemRequest;
+} | {
+    readonly tag: "ExecuteRequest";
+    readonly val: ExecuteRequest;
+} | {
+    readonly tag: "WriteStdinRequest";
+    readonly val: WriteStdinRequest;
+} | {
+    readonly tag: "CloseStdinRequest";
+    readonly val: CloseStdinRequest;
+} | {
+    readonly tag: "KillProcessRequest";
+    readonly val: KillProcessRequest;
+} | {
+    readonly tag: "GetProcessSnapshotRequest";
+    readonly val: GetProcessSnapshotRequest;
+} | {
+    readonly tag: "FindListenerRequest";
+    readonly val: FindListenerRequest;
+} | {
+    readonly tag: "FindBoundUdpRequest";
+    readonly val: FindBoundUdpRequest;
+} | {
+    readonly tag: "GetSignalStateRequest";
+    readonly val: GetSignalStateRequest;
+} | {
+    readonly tag: "GetZombieTimerCountRequest";
+    readonly val: GetZombieTimerCountRequest;
+} | {
+    readonly tag: "HostFilesystemCallRequest";
+    readonly val: HostFilesystemCallRequest;
+} | {
+    readonly tag: "PersistenceLoadRequest";
+    readonly val: PersistenceLoadRequest;
+} | {
+    readonly tag: "PersistenceFlushRequest";
+    readonly val: PersistenceFlushRequest;
+} | {
+    readonly tag: "VmFetchRequest";
+    readonly val: VmFetchRequest;
+} | {
+    readonly tag: "ExtEnvelope";
+    readonly val: ExtEnvelope;
+} | {
+    readonly tag: "GuestKernelCallRequest";
+    readonly val: GuestKernelCallRequest;
+} | {
+    readonly tag: "ResizePtyRequest";
+    readonly val: ResizePtyRequest;
+} | {
+    readonly tag: "GetResourceSnapshotRequest";
+    readonly val: GetResourceSnapshotRequest;
+} | {
+    readonly tag: "LinkPackageRequest";
+    readonly val: LinkPackageRequest;
+} | {
+    readonly tag: "ProvidedCommandsRequest";
+    readonly val: ProvidedCommandsRequest;
+} | {
+    readonly tag: "ScheduleCronRequest";
+    readonly val: ScheduleCronRequest;
+} | {
+    readonly tag: "ListCronJobsRequest";
+    readonly val: ListCronJobsRequest;
+} | {
+    readonly tag: "CancelCronJobRequest";
+    readonly val: CancelCronJobRequest;
+} | {
+    readonly tag: "WakeCronRequest";
+    readonly val: WakeCronRequest;
+} | {
+    readonly tag: "CompleteCronRunRequest";
+    readonly val: CompleteCronRunRequest;
+} | {
+    readonly tag: "ExportCronStateRequest";
+    readonly val: ExportCronStateRequest;
+} | {
+    readonly tag: "ImportCronStateRequest";
+    readonly val: ImportCronStateRequest;
+} | {
+    readonly tag: "InitializeVmRequest";
+    readonly val: InitializeVmRequest;
+} | {
+    readonly tag: "CloseSessionRequest";
+    readonly val: CloseSessionRequest;
+};
+export declare function readRequestPayload(bc: bare.ByteCursor): RequestPayload;
+export declare function writeRequestPayload(bc: bare.ByteCursor, x: RequestPayload): void;
+export type RequestFrame = {
+    readonly schema: ProtocolSchema;
+    readonly requestId: RequestId;
+    readonly ownership: OwnershipScope;
+    readonly payload: RequestPayload;
+};
+export declare function readRequestFrame(bc: bare.ByteCursor): RequestFrame;
+export declare function writeRequestFrame(bc: bare.ByteCursor, x: RequestFrame): void;
+export type AuthenticatedResponse = {
+    readonly sidecarId: string;
+    readonly connectionId: string;
+    readonly maxFrameBytes: u32;
+};
+export declare function readAuthenticatedResponse(bc: bare.ByteCursor): AuthenticatedResponse;
+export declare function writeAuthenticatedResponse(bc: bare.ByteCursor, x: AuthenticatedResponse): void;
+export type SessionOpenedResponse = {
+    readonly sessionId: string;
+    readonly ownerConnectionId: string;
+};
+export declare function readSessionOpenedResponse(bc: bare.ByteCursor): SessionOpenedResponse;
+export declare function writeSessionOpenedResponse(bc: bare.ByteCursor, x: SessionOpenedResponse): void;
+export type SessionClosedResponse = {
+    readonly sessionId: string;
+};
+export declare function readSessionClosedResponse(bc: bare.ByteCursor): SessionClosedResponse;
+export declare function writeSessionClosedResponse(bc: bare.ByteCursor, x: SessionClosedResponse): void;
+export type VmCreatedResponse = {
+    readonly vmId: string;
+    readonly guestCwd: string;
+    readonly guestEnv: ReadonlyMap<string, string>;
+    /**
+     * Sidecar-resolved bound for completed host process callback routes. Clients
+     * retain only lightweight terminal correlation up to this count.
+     */
+    readonly processRouteRetention: u64;
+};
+export declare function readVmCreatedResponse(bc: bare.ByteCursor): VmCreatedResponse;
+export declare function writeVmCreatedResponse(bc: bare.ByteCursor, x: VmCreatedResponse): void;
+export type VmDisposedResponse = {
+    readonly vmId: string;
+};
+export declare function readVmDisposedResponse(bc: bare.ByteCursor): VmDisposedResponse;
+export declare function writeVmDisposedResponse(bc: bare.ByteCursor, x: VmDisposedResponse): void;
+export type RootFilesystemBootstrappedResponse = {
+    readonly entryCount: u32;
+};
+export declare function readRootFilesystemBootstrappedResponse(bc: bare.ByteCursor): RootFilesystemBootstrappedResponse;
+export declare function writeRootFilesystemBootstrappedResponse(bc: bare.ByteCursor, x: RootFilesystemBootstrappedResponse): void;
+export type VmConfiguredResponse = {
+    readonly appliedMounts: u32;
+    readonly projectedCommands: readonly ProjectedCommand[];
+    readonly agents: readonly AgentosProjectedAgent[];
+};
+export declare function readVmConfiguredResponse(bc: bare.ByteCursor): VmConfiguredResponse;
+export declare function writeVmConfiguredResponse(bc: bare.ByteCursor, x: VmConfiguredResponse): void;
+export type HostCallbacksRegisteredResponse = {
+    readonly registration: string;
+    readonly commandCount: u32;
+};
+export declare function readHostCallbacksRegisteredResponse(bc: bare.ByteCursor): HostCallbacksRegisteredResponse;
+export declare function writeHostCallbacksRegisteredResponse(bc: bare.ByteCursor, x: HostCallbacksRegisteredResponse): void;
+export type VmInitializedResponse = {
+    readonly vmId: string;
+    readonly guestCwd: string;
+    readonly guestEnv: ReadonlyMap<string, string>;
+    readonly processRouteRetention: u64;
+    readonly appliedMounts: u32;
+    readonly projectedCommands: readonly ProjectedCommand[];
+    readonly agents: readonly AgentosProjectedAgent[];
+    readonly hostCallbacks: readonly HostCallbacksRegisteredResponse[];
+};
+export declare function readVmInitializedResponse(bc: bare.ByteCursor): VmInitializedResponse;
+export declare function writeVmInitializedResponse(bc: bare.ByteCursor, x: VmInitializedResponse): void;
+export type LayerCreatedResponse = {
+    readonly layerId: string;
+};
+export declare function readLayerCreatedResponse(bc: bare.ByteCursor): LayerCreatedResponse;
+export declare function writeLayerCreatedResponse(bc: bare.ByteCursor, x: LayerCreatedResponse): void;
+export type LayerSealedResponse = {
+    readonly layerId: string;
+};
+export declare function readLayerSealedResponse(bc: bare.ByteCursor): LayerSealedResponse;
+export declare function writeLayerSealedResponse(bc: bare.ByteCursor, x: LayerSealedResponse): void;
+export type SnapshotImportedResponse = {
+    readonly layerId: string;
+};
+export declare function readSnapshotImportedResponse(bc: bare.ByteCursor): SnapshotImportedResponse;
+export declare function writeSnapshotImportedResponse(bc: bare.ByteCursor, x: SnapshotImportedResponse): void;
+export type SnapshotExportedResponse = {
+    readonly layerId: string;
+    readonly entries: readonly RootFilesystemEntry[];
+};
+export declare function readSnapshotExportedResponse(bc: bare.ByteCursor): SnapshotExportedResponse;
+export declare function writeSnapshotExportedResponse(bc: bare.ByteCursor, x: SnapshotExportedResponse): void;
+export type OverlayCreatedResponse = {
+    readonly layerId: string;
+};
+export declare function readOverlayCreatedResponse(bc: bare.ByteCursor): OverlayCreatedResponse;
+export declare function writeOverlayCreatedResponse(bc: bare.ByteCursor, x: OverlayCreatedResponse): void;
+export type GuestFilesystemStat = {
+    readonly mode: u32;
+    readonly size: u64;
+    readonly blocks: u64;
+    readonly dev: u64;
+    readonly rdev: u64;
+    readonly isDirectory: boolean;
+    readonly isSymbolicLink: boolean;
+    readonly atimeMs: u64;
+    readonly mtimeMs: u64;
+    readonly ctimeMs: u64;
+    readonly birthtimeMs: u64;
+    readonly ino: u64;
+    readonly nlink: u64;
+    readonly uid: u32;
+    readonly gid: u32;
+};
+export declare function readGuestFilesystemStat(bc: bare.ByteCursor): GuestFilesystemStat;
+export declare function writeGuestFilesystemStat(bc: bare.ByteCursor, x: GuestFilesystemStat): void;
+export type GuestDirEntry = {
+    readonly name: string;
+    readonly path: string;
+    readonly isDirectory: boolean;
+    readonly isSymbolicLink: boolean;
+    readonly size: u64;
+};
+export declare function readGuestDirEntry(bc: bare.ByteCursor): GuestDirEntry;
+export declare function writeGuestDirEntry(bc: bare.ByteCursor, x: GuestDirEntry): void;
+export type GuestFilesystemResultResponse = {
+    readonly operation: GuestFilesystemOperation;
+    readonly path: string;
+    readonly content: string | null;
+    readonly encoding: RootFilesystemEntryEncoding | null;
+    readonly entries: readonly GuestDirEntry[] | null;
+    readonly stat: GuestFilesystemStat | null;
+    readonly exists: boolean | null;
+    readonly target: string | null;
+};
+export declare function readGuestFilesystemResultResponse(bc: bare.ByteCursor): GuestFilesystemResultResponse;
+export declare function writeGuestFilesystemResultResponse(bc: bare.ByteCursor, x: GuestFilesystemResultResponse): void;
+export type GuestKernelResultResponse = {
+    readonly payload: ArrayBuffer;
+};
+export declare function readGuestKernelResultResponse(bc: bare.ByteCursor): GuestKernelResultResponse;
+export declare function writeGuestKernelResultResponse(bc: bare.ByteCursor, x: GuestKernelResultResponse): void;
+export type RootFilesystemSnapshotResponse = {
+    readonly entries: readonly RootFilesystemEntry[];
+};
+export declare function readRootFilesystemSnapshotResponse(bc: bare.ByteCursor): RootFilesystemSnapshotResponse;
+export declare function writeRootFilesystemSnapshotResponse(bc: bare.ByteCursor, x: RootFilesystemSnapshotResponse): void;
+export type ProcessStartedResponse = {
+    readonly processId: string;
+    readonly pid: u32 | null;
+};
+export declare function readProcessStartedResponse(bc: bare.ByteCursor): ProcessStartedResponse;
+export declare function writeProcessStartedResponse(bc: bare.ByteCursor, x: ProcessStartedResponse): void;
+export type StdinWrittenResponse = {
+    readonly processId: string;
+    readonly acceptedBytes: u64;
+};
+export declare function readStdinWrittenResponse(bc: bare.ByteCursor): StdinWrittenResponse;
+export declare function writeStdinWrittenResponse(bc: bare.ByteCursor, x: StdinWrittenResponse): void;
+export type PtyResizedResponse = {
+    readonly processId: string;
+    readonly cols: u16;
+    readonly rows: u16;
+};
+export declare function readPtyResizedResponse(bc: bare.ByteCursor): PtyResizedResponse;
+export declare function writePtyResizedResponse(bc: bare.ByteCursor, x: PtyResizedResponse): void;
+export type StdinClosedResponse = {
+    readonly processId: string;
+};
+export declare function readStdinClosedResponse(bc: bare.ByteCursor): StdinClosedResponse;
+export declare function writeStdinClosedResponse(bc: bare.ByteCursor, x: StdinClosedResponse): void;
+export type ProcessKilledResponse = {
+    readonly processId: string;
+};
+export declare function readProcessKilledResponse(bc: bare.ByteCursor): ProcessKilledResponse;
+export declare function writeProcessKilledResponse(bc: bare.ByteCursor, x: ProcessKilledResponse): void;
+export declare enum ProcessSnapshotStatus {
+    Running = "Running",
+    Exited = "Exited",
+    Stopped = "Stopped"
+}
+export declare function readProcessSnapshotStatus(bc: bare.ByteCursor): ProcessSnapshotStatus;
+export declare function writeProcessSnapshotStatus(bc: bare.ByteCursor, x: ProcessSnapshotStatus): void;
+export type ProcessSnapshotEntry = {
+    readonly processId: string;
+    readonly pid: u32;
+    readonly ppid: u32;
+    readonly pgid: u32;
+    readonly sid: u32;
+    readonly driver: string;
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly cwd: string;
+    readonly status: ProcessSnapshotStatus;
+    readonly exitCode: i32 | null;
+    readonly startTimeMs: u64;
+    readonly exitTimeMs: u64 | null;
+};
+export declare function readProcessSnapshotEntry(bc: bare.ByteCursor): ProcessSnapshotEntry;
+export declare function writeProcessSnapshotEntry(bc: bare.ByteCursor, x: ProcessSnapshotEntry): void;
+export type ProcessSnapshotResponse = {
+    readonly processes: readonly ProcessSnapshotEntry[];
+};
+export declare function readProcessSnapshotResponse(bc: bare.ByteCursor): ProcessSnapshotResponse;
+export declare function writeProcessSnapshotResponse(bc: bare.ByteCursor, x: ProcessSnapshotResponse): void;
+export type QueueSnapshotEntry = {
+    readonly name: string;
+    readonly category: string;
+    readonly depth: u64;
+    readonly highWater: u64;
+    readonly capacity: u64;
+    readonly fillPercent: u64;
+};
+export declare function readQueueSnapshotEntry(bc: bare.ByteCursor): QueueSnapshotEntry;
+export declare function writeQueueSnapshotEntry(bc: bare.ByteCursor, x: QueueSnapshotEntry): void;
+export type ResourceSnapshotResponse = {
+    readonly runningProcesses: u64;
+    readonly exitedProcesses: u64;
+    readonly fdTables: u64;
+    readonly openFds: u64;
+    readonly pipes: u64;
+    readonly pipeBufferedBytes: u64;
+    readonly ptys: u64;
+    readonly ptyBufferedInputBytes: u64;
+    readonly ptyBufferedOutputBytes: u64;
+    readonly sockets: u64;
+    readonly socketListeners: u64;
+    readonly socketConnections: u64;
+    readonly socketBufferedBytes: u64;
+    readonly socketDatagramQueueLen: u64;
+    readonly queueSnapshots: readonly QueueSnapshotEntry[];
+};
+export declare function readResourceSnapshotResponse(bc: bare.ByteCursor): ResourceSnapshotResponse;
+export declare function writeResourceSnapshotResponse(bc: bare.ByteCursor, x: ResourceSnapshotResponse): void;
+export type SocketStateEntry = {
+    readonly processId: string;
+    readonly host: string | null;
+    readonly port: u16 | null;
+    readonly path: string | null;
+};
+export declare function readSocketStateEntry(bc: bare.ByteCursor): SocketStateEntry;
+export declare function writeSocketStateEntry(bc: bare.ByteCursor, x: SocketStateEntry): void;
+export type ListenerSnapshotResponse = {
+    readonly listener: SocketStateEntry | null;
+};
+export declare function readListenerSnapshotResponse(bc: bare.ByteCursor): ListenerSnapshotResponse;
+export declare function writeListenerSnapshotResponse(bc: bare.ByteCursor, x: ListenerSnapshotResponse): void;
+export type BoundUdpSnapshotResponse = {
+    readonly socket: SocketStateEntry | null;
+};
+export declare function readBoundUdpSnapshotResponse(bc: bare.ByteCursor): BoundUdpSnapshotResponse;
+export declare function writeBoundUdpSnapshotResponse(bc: bare.ByteCursor, x: BoundUdpSnapshotResponse): void;
+export declare enum SignalDispositionAction {
+    Default = "Default",
+    Ignore = "Ignore",
+    User = "User"
+}
+export declare function readSignalDispositionAction(bc: bare.ByteCursor): SignalDispositionAction;
+export declare function writeSignalDispositionAction(bc: bare.ByteCursor, x: SignalDispositionAction): void;
+export type SignalHandlerRegistration = {
+    readonly action: SignalDispositionAction;
+    readonly mask: Uint32Array;
+    readonly flags: u32;
+};
+export declare function readSignalHandlerRegistration(bc: bare.ByteCursor): SignalHandlerRegistration;
+export declare function writeSignalHandlerRegistration(bc: bare.ByteCursor, x: SignalHandlerRegistration): void;
+export type SignalStateResponse = {
+    readonly processId: string;
+    readonly handlers: ReadonlyMap<u32, SignalHandlerRegistration>;
+};
+export declare function readSignalStateResponse(bc: bare.ByteCursor): SignalStateResponse;
+export declare function writeSignalStateResponse(bc: bare.ByteCursor, x: SignalStateResponse): void;
+export type ZombieTimerCountResponse = {
+    readonly count: u64;
+};
+export declare function readZombieTimerCountResponse(bc: bare.ByteCursor): ZombieTimerCountResponse;
+export declare function writeZombieTimerCountResponse(bc: bare.ByteCursor, x: ZombieTimerCountResponse): void;
+export type FilesystemResultResponse = {
+    readonly operation: FilesystemOperation;
+    readonly status: string;
+    readonly payloadSizeBytes: u64;
+};
+export declare function readFilesystemResultResponse(bc: bare.ByteCursor): FilesystemResultResponse;
+export declare function writeFilesystemResultResponse(bc: bare.ByteCursor, x: FilesystemResultResponse): void;
+export type PermissionDecisionResponse = {
+    readonly capability: string;
+    readonly decision: PermissionMode;
+};
+export declare function readPermissionDecisionResponse(bc: bare.ByteCursor): PermissionDecisionResponse;
+export declare function writePermissionDecisionResponse(bc: bare.ByteCursor, x: PermissionDecisionResponse): void;
+export type PersistenceStateResponse = {
+    readonly key: string;
+    readonly found: boolean;
+    readonly payloadSizeBytes: u64;
+};
+export declare function readPersistenceStateResponse(bc: bare.ByteCursor): PersistenceStateResponse;
+export declare function writePersistenceStateResponse(bc: bare.ByteCursor, x: PersistenceStateResponse): void;
+export type PersistenceFlushedResponse = {
+    readonly key: string;
+    readonly committedBytes: u64;
+};
+export declare function readPersistenceFlushedResponse(bc: bare.ByteCursor): PersistenceFlushedResponse;
+export declare function writePersistenceFlushedResponse(bc: bare.ByteCursor, x: PersistenceFlushedResponse): void;
+export type RejectedResponse = {
+    readonly code: string;
+    readonly message: string;
+};
+export declare function readRejectedResponse(bc: bare.ByteCursor): RejectedResponse;
+export declare function writeRejectedResponse(bc: bare.ByteCursor, x: RejectedResponse): void;
+export type VmFetchResponse = {
+    readonly responseJson: string;
+};
+export declare function readVmFetchResponse(bc: bare.ByteCursor): VmFetchResponse;
+export declare function writeVmFetchResponse(bc: bare.ByteCursor, x: VmFetchResponse): void;
+export type CronAlarm = {
+    readonly generation: u64;
+    readonly nextAlarmMs: u64 | null;
+};
+export declare function readCronAlarm(bc: bare.ByteCursor): CronAlarm;
+export declare function writeCronAlarm(bc: bare.ByteCursor, x: CronAlarm): void;
+export type CronJobEntry = {
+    readonly id: string;
+    readonly schedule: string;
+    readonly action: JsonUtf8;
+    readonly overlap: CronOverlap;
+    readonly lastRunMs: u64 | null;
+    readonly nextRunMs: u64 | null;
+    readonly runCount: u64;
+    readonly running: boolean;
+};
+export declare function readCronJobEntry(bc: bare.ByteCursor): CronJobEntry;
+export declare function writeCronJobEntry(bc: bare.ByteCursor, x: CronJobEntry): void;
+export type CronRun = {
+    readonly runId: string;
+    readonly jobId: string;
+    readonly action: JsonUtf8;
+};
+export declare function readCronRun(bc: bare.ByteCursor): CronRun;
+export declare function writeCronRun(bc: bare.ByteCursor, x: CronRun): void;
+export declare enum CronEventKind {
+    Fire = "Fire",
+    Complete = "Complete",
+    Error = "Error"
+}
+export declare function readCronEventKind(bc: bare.ByteCursor): CronEventKind;
+export declare function writeCronEventKind(bc: bare.ByteCursor, x: CronEventKind): void;
+export type CronEventRecord = {
+    readonly kind: CronEventKind;
+    readonly jobId: string;
+    readonly timeMs: u64;
+    readonly durationMs: u64 | null;
+    readonly error: string | null;
+};
+export declare function readCronEventRecord(bc: bare.ByteCursor): CronEventRecord;
+export declare function writeCronEventRecord(bc: bare.ByteCursor, x: CronEventRecord): void;
+export type CronScheduledResponse = {
+    readonly id: string;
+    readonly alarm: CronAlarm;
+};
+export declare function readCronScheduledResponse(bc: bare.ByteCursor): CronScheduledResponse;
+export declare function writeCronScheduledResponse(bc: bare.ByteCursor, x: CronScheduledResponse): void;
+export type CronJobsResponse = {
+    readonly jobs: readonly CronJobEntry[];
+    readonly alarm: CronAlarm;
+};
+export declare function readCronJobsResponse(bc: bare.ByteCursor): CronJobsResponse;
+export declare function writeCronJobsResponse(bc: bare.ByteCursor, x: CronJobsResponse): void;
+export type CronCancelledResponse = {
+    readonly id: string;
+    readonly cancelled: boolean;
+    readonly alarm: CronAlarm;
+};
+export declare function readCronCancelledResponse(bc: bare.ByteCursor): CronCancelledResponse;
+export declare function writeCronCancelledResponse(bc: bare.ByteCursor, x: CronCancelledResponse): void;
+export type CronWakeResponse = {
+    readonly alarm: CronAlarm;
+    readonly runs: readonly CronRun[];
+    readonly events: readonly CronEventRecord[];
+};
+export declare function readCronWakeResponse(bc: bare.ByteCursor): CronWakeResponse;
+export declare function writeCronWakeResponse(bc: bare.ByteCursor, x: CronWakeResponse): void;
+export type CronRunCompletedResponse = {
+    readonly alarm: CronAlarm;
+    readonly runs: readonly CronRun[];
+    readonly events: readonly CronEventRecord[];
+};
+export declare function readCronRunCompletedResponse(bc: bare.ByteCursor): CronRunCompletedResponse;
+export declare function writeCronRunCompletedResponse(bc: bare.ByteCursor, x: CronRunCompletedResponse): void;
+export type CronStateExportedResponse = {
+    readonly state: JsonUtf8;
+};
+export declare function readCronStateExportedResponse(bc: bare.ByteCursor): CronStateExportedResponse;
+export declare function writeCronStateExportedResponse(bc: bare.ByteCursor, x: CronStateExportedResponse): void;
+export type CronStateImportedResponse = {
+    readonly alarm: CronAlarm;
+    readonly runs: readonly CronRun[];
+    readonly events: readonly CronEventRecord[];
+};
+export declare function readCronStateImportedResponse(bc: bare.ByteCursor): CronStateImportedResponse;
+export declare function writeCronStateImportedResponse(bc: bare.ByteCursor, x: CronStateImportedResponse): void;
+export type ResponsePayload = {
+    readonly tag: "AuthenticatedResponse";
+    readonly val: AuthenticatedResponse;
+} | {
+    readonly tag: "SessionOpenedResponse";
+    readonly val: SessionOpenedResponse;
+} | {
+    readonly tag: "VmCreatedResponse";
+    readonly val: VmCreatedResponse;
+} | {
+    readonly tag: "VmDisposedResponse";
+    readonly val: VmDisposedResponse;
+} | {
+    readonly tag: "RootFilesystemBootstrappedResponse";
+    readonly val: RootFilesystemBootstrappedResponse;
+} | {
+    readonly tag: "VmConfiguredResponse";
+    readonly val: VmConfiguredResponse;
+} | {
+    readonly tag: "HostCallbacksRegisteredResponse";
+    readonly val: HostCallbacksRegisteredResponse;
+} | {
+    readonly tag: "LayerCreatedResponse";
+    readonly val: LayerCreatedResponse;
+} | {
+    readonly tag: "LayerSealedResponse";
+    readonly val: LayerSealedResponse;
+} | {
+    readonly tag: "SnapshotImportedResponse";
+    readonly val: SnapshotImportedResponse;
+} | {
+    readonly tag: "SnapshotExportedResponse";
+    readonly val: SnapshotExportedResponse;
+} | {
+    readonly tag: "OverlayCreatedResponse";
+    readonly val: OverlayCreatedResponse;
+} | {
+    readonly tag: "GuestFilesystemResultResponse";
+    readonly val: GuestFilesystemResultResponse;
+} | {
+    readonly tag: "RootFilesystemSnapshotResponse";
+    readonly val: RootFilesystemSnapshotResponse;
+} | {
+    readonly tag: "ProcessStartedResponse";
+    readonly val: ProcessStartedResponse;
+} | {
+    readonly tag: "StdinWrittenResponse";
+    readonly val: StdinWrittenResponse;
+} | {
+    readonly tag: "StdinClosedResponse";
+    readonly val: StdinClosedResponse;
+} | {
+    readonly tag: "ProcessKilledResponse";
+    readonly val: ProcessKilledResponse;
+} | {
+    readonly tag: "ProcessSnapshotResponse";
+    readonly val: ProcessSnapshotResponse;
+} | {
+    readonly tag: "ListenerSnapshotResponse";
+    readonly val: ListenerSnapshotResponse;
+} | {
+    readonly tag: "BoundUdpSnapshotResponse";
+    readonly val: BoundUdpSnapshotResponse;
+} | {
+    readonly tag: "SignalStateResponse";
+    readonly val: SignalStateResponse;
+} | {
+    readonly tag: "ZombieTimerCountResponse";
+    readonly val: ZombieTimerCountResponse;
+} | {
+    readonly tag: "FilesystemResultResponse";
+    readonly val: FilesystemResultResponse;
+} | {
+    readonly tag: "PermissionDecisionResponse";
+    readonly val: PermissionDecisionResponse;
+} | {
+    readonly tag: "PersistenceStateResponse";
+    readonly val: PersistenceStateResponse;
+} | {
+    readonly tag: "PersistenceFlushedResponse";
+    readonly val: PersistenceFlushedResponse;
+} | {
+    readonly tag: "RejectedResponse";
+    readonly val: RejectedResponse;
+} | {
+    readonly tag: "VmFetchResponse";
+    readonly val: VmFetchResponse;
+} | {
+    readonly tag: "ExtEnvelope";
+    readonly val: ExtEnvelope;
+} | {
+    readonly tag: "GuestKernelResultResponse";
+    readonly val: GuestKernelResultResponse;
+} | {
+    readonly tag: "PtyResizedResponse";
+    readonly val: PtyResizedResponse;
+} | {
+    readonly tag: "ResourceSnapshotResponse";
+    readonly val: ResourceSnapshotResponse;
+} | {
+    readonly tag: "PackageLinkedResponse";
+    readonly val: PackageLinkedResponse;
+} | {
+    readonly tag: "ProvidedCommandsResponse";
+    readonly val: ProvidedCommandsResponse;
+} | {
+    readonly tag: "CronScheduledResponse";
+    readonly val: CronScheduledResponse;
+} | {
+    readonly tag: "CronJobsResponse";
+    readonly val: CronJobsResponse;
+} | {
+    readonly tag: "CronCancelledResponse";
+    readonly val: CronCancelledResponse;
+} | {
+    readonly tag: "CronWakeResponse";
+    readonly val: CronWakeResponse;
+} | {
+    readonly tag: "CronRunCompletedResponse";
+    readonly val: CronRunCompletedResponse;
+} | {
+    readonly tag: "CronStateExportedResponse";
+    readonly val: CronStateExportedResponse;
+} | {
+    readonly tag: "CronStateImportedResponse";
+    readonly val: CronStateImportedResponse;
+} | {
+    readonly tag: "VmInitializedResponse";
+    readonly val: VmInitializedResponse;
+} | {
+    readonly tag: "SessionClosedResponse";
+    readonly val: SessionClosedResponse;
+};
+export declare function readResponsePayload(bc: bare.ByteCursor): ResponsePayload;
+export declare function writeResponsePayload(bc: bare.ByteCursor, x: ResponsePayload): void;
+export type ResponseFrame = {
+    readonly schema: ProtocolSchema;
+    readonly requestId: RequestId;
+    readonly ownership: OwnershipScope;
+    readonly payload: ResponsePayload;
+};
+export declare function readResponseFrame(bc: bare.ByteCursor): ResponseFrame;
+export declare function writeResponseFrame(bc: bare.ByteCursor, x: ResponseFrame): void;
+export declare enum VmLifecycleState {
+    Creating = "Creating",
+    Ready = "Ready",
+    Disposing = "Disposing",
+    Disposed = "Disposed",
+    Failed = "Failed"
+}
+export declare function readVmLifecycleState(bc: bare.ByteCursor): VmLifecycleState;
+export declare function writeVmLifecycleState(bc: bare.ByteCursor, x: VmLifecycleState): void;
+export type VmLifecycleEvent = {
+    readonly state: VmLifecycleState;
+};
+export declare function readVmLifecycleEvent(bc: bare.ByteCursor): VmLifecycleEvent;
+export declare function writeVmLifecycleEvent(bc: bare.ByteCursor, x: VmLifecycleEvent): void;
+export declare enum StreamChannel {
+    Stdout = "Stdout",
+    Stderr = "Stderr"
+}
+export declare function readStreamChannel(bc: bare.ByteCursor): StreamChannel;
+export declare function writeStreamChannel(bc: bare.ByteCursor, x: StreamChannel): void;
+export type ProcessOutputEvent = {
+    readonly processId: string;
+    readonly channel: StreamChannel;
+    readonly chunk: ArrayBuffer;
+};
+export declare function readProcessOutputEvent(bc: bare.ByteCursor): ProcessOutputEvent;
+export declare function writeProcessOutputEvent(bc: bare.ByteCursor, x: ProcessOutputEvent): void;
+export type ProcessExitedEvent = {
+    readonly processId: string;
+    readonly exitCode: i32;
+    readonly stdout: ArrayBuffer | null;
+    readonly stderr: ArrayBuffer | null;
+    readonly error: RejectedResponse | null;
+};
+export declare function readProcessExitedEvent(bc: bare.ByteCursor): ProcessExitedEvent;
+export declare function writeProcessExitedEvent(bc: bare.ByteCursor, x: ProcessExitedEvent): void;
+/**
+ * Asynchronous cron state produced after a sidecar-owned action finishes. Hosts
+ * use the alarm to arm their one wake primitive, deliver lifecycle records, and
+ * invoke only the callback runs whose closures cannot cross the protocol.
+ */
+export type CronDispatchEvent = {
+    readonly alarm: CronAlarm;
+    readonly runs: readonly CronRun[];
+    readonly events: readonly CronEventRecord[];
+};
+export declare function readCronDispatchEvent(bc: bare.ByteCursor): CronDispatchEvent;
+export declare function writeCronDispatchEvent(bc: bare.ByteCursor, x: CronDispatchEvent): void;
+export type StructuredEvent = {
+    readonly name: string;
+    readonly detail: ReadonlyMap<string, string>;
+};
+export declare function readStructuredEvent(bc: bare.ByteCursor): StructuredEvent;
+export declare function writeStructuredEvent(bc: bare.ByteCursor, x: StructuredEvent): void;
+export type EventPayload = {
+    readonly tag: "VmLifecycleEvent";
+    readonly val: VmLifecycleEvent;
+} | {
+    readonly tag: "ProcessOutputEvent";
+    readonly val: ProcessOutputEvent;
+} | {
+    readonly tag: "ProcessExitedEvent";
+    readonly val: ProcessExitedEvent;
+} | {
+    readonly tag: "CronDispatchEvent";
+    readonly val: CronDispatchEvent;
+} | {
+    readonly tag: "StructuredEvent";
+    readonly val: StructuredEvent;
+} | {
+    readonly tag: "ExtEnvelope";
+    readonly val: ExtEnvelope;
+};
+export declare function readEventPayload(bc: bare.ByteCursor): EventPayload;
+export declare function writeEventPayload(bc: bare.ByteCursor, x: EventPayload): void;
+export type EventFrame = {
+    readonly schema: ProtocolSchema;
+    readonly ownership: OwnershipScope;
+    readonly payload: EventPayload;
+};
+export declare function readEventFrame(bc: bare.ByteCursor): EventFrame;
+export declare function writeEventFrame(bc: bare.ByteCursor, x: EventFrame): void;
+export type HostCallbackRequest = {
+    readonly invocationId: string;
+    readonly callbackKey: string;
+    readonly input: JsonUtf8;
+    readonly timeoutMs: u64;
+};
+export declare function readHostCallbackRequest(bc: bare.ByteCursor): HostCallbackRequest;
+export declare function writeHostCallbackRequest(bc: bare.ByteCursor, x: HostCallbackRequest): void;
+export type JsBridgeCallRequest = {
+    readonly callId: string;
+    readonly mountId: string;
+    readonly operation: string;
+    readonly args: JsonUtf8;
+};
+export declare function readJsBridgeCallRequest(bc: bare.ByteCursor): JsBridgeCallRequest;
+export declare function writeJsBridgeCallRequest(bc: bare.ByteCursor, x: JsBridgeCallRequest): void;
+export type SidecarRequestPayload = {
+    readonly tag: "HostCallbackRequest";
+    readonly val: HostCallbackRequest;
+} | {
+    readonly tag: "JsBridgeCallRequest";
+    readonly val: JsBridgeCallRequest;
+} | {
+    readonly tag: "ExtEnvelope";
+    readonly val: ExtEnvelope;
+};
+export declare function readSidecarRequestPayload(bc: bare.ByteCursor): SidecarRequestPayload;
+export declare function writeSidecarRequestPayload(bc: bare.ByteCursor, x: SidecarRequestPayload): void;
+export type SidecarRequestFrame = {
+    readonly schema: ProtocolSchema;
+    readonly requestId: RequestId;
+    readonly ownership: OwnershipScope;
+    readonly payload: SidecarRequestPayload;
+};
+export declare function readSidecarRequestFrame(bc: bare.ByteCursor): SidecarRequestFrame;
+export declare function writeSidecarRequestFrame(bc: bare.ByteCursor, x: SidecarRequestFrame): void;
+export type HostCallbackResultResponse = {
+    readonly invocationId: string;
+    readonly result: JsonUtf8 | null;
+    readonly error: string | null;
+};
+export declare function readHostCallbackResultResponse(bc: bare.ByteCursor): HostCallbackResultResponse;
+export declare function writeHostCallbackResultResponse(bc: bare.ByteCursor, x: HostCallbackResultResponse): void;
+export type JsBridgeResultResponse = {
+    readonly callId: string;
+    readonly result: JsonUtf8 | null;
+    readonly error: string | null;
+};
+export declare function readJsBridgeResultResponse(bc: bare.ByteCursor): JsBridgeResultResponse;
+export declare function writeJsBridgeResultResponse(bc: bare.ByteCursor, x: JsBridgeResultResponse): void;
+export type SidecarResponsePayload = {
+    readonly tag: "HostCallbackResultResponse";
+    readonly val: HostCallbackResultResponse;
+} | {
+    readonly tag: "JsBridgeResultResponse";
+    readonly val: JsBridgeResultResponse;
+} | {
+    readonly tag: "ExtEnvelope";
+    readonly val: ExtEnvelope;
+};
+export declare function readSidecarResponsePayload(bc: bare.ByteCursor): SidecarResponsePayload;
+export declare function writeSidecarResponsePayload(bc: bare.ByteCursor, x: SidecarResponsePayload): void;
+export type SidecarResponseFrame = {
+    readonly schema: ProtocolSchema;
+    readonly requestId: RequestId;
+    readonly ownership: OwnershipScope;
+    readonly payload: SidecarResponsePayload;
+};
+export declare function readSidecarResponseFrame(bc: bare.ByteCursor): SidecarResponseFrame;
+export declare function writeSidecarResponseFrame(bc: bare.ByteCursor, x: SidecarResponseFrame): void;
+export type ProtocolFrame = {
+    readonly tag: "RequestFrame";
+    readonly val: RequestFrame;
+} | {
+    readonly tag: "ResponseFrame";
+    readonly val: ResponseFrame;
+} | {
+    readonly tag: "EventFrame";
+    readonly val: EventFrame;
+} | {
+    readonly tag: "SidecarRequestFrame";
+    readonly val: SidecarRequestFrame;
+} | {
+    readonly tag: "SidecarResponseFrame";
+    readonly val: SidecarResponseFrame;
+};
+export declare function readProtocolFrame(bc: bare.ByteCursor): ProtocolFrame;
+export declare function writeProtocolFrame(bc: bare.ByteCursor, x: ProtocolFrame): void;
+export declare function encodeProtocolFrame(x: ProtocolFrame, config?: Partial<bare.Config>): Uint8Array;
+export declare function decodeProtocolFrame(bytes: Uint8Array): ProtocolFrame;