@rivet-dev/agentos-runtime-core 0.0.0-main.2f99c77 → 0.0.0-main.5ac5a14

package/dist/generated-protocol.js

@@ -784,15 +784,31 @@ export function writeMountPluginDescriptor(bc, x) {
 export function readMountDescriptor(bc) {
     return {
         guestPath: bare.readString(bc),
+        guestSource: bare.readString(bc),
+        guestFstype: bare.readString(bc),
         readOnly: bare.readBool(bc),
         plugin: readMountPluginDescriptor(bc),
     };
 }
 export function writeMountDescriptor(bc, x) {
     bare.writeString(bc, x.guestPath);
+    bare.writeString(bc, x.guestSource);
+    bare.writeString(bc, x.guestFstype);
     bare.writeBool(bc, x.readOnly);
     writeMountPluginDescriptor(bc, x.plugin);
 }
+export function readMountInfo(bc) {
+    return {
+        path: bare.readString(bc),
+        kind: bare.readString(bc),
+        readOnly: bare.readBool(bc),
+    };
+}
+export function writeMountInfo(bc, x) {
+    bare.writeString(bc, x.path);
+    bare.writeString(bc, x.kind);
+    bare.writeBool(bc, x.readOnly);
+}
 export function readSoftwareDescriptor(bc) {
     return {
         packageName: bare.readString(bc),
@@ -1086,7 +1102,7 @@ export function readConfigureVmRequest(bc) {
         packages: read20(bc),
         packagesMountAt: bare.readString(bc),
         bootstrapCommands: read6(bc),
-        toolShimCommands: read6(bc),
+        bindingShimCommands: read6(bc),
     };
 }
 export function writeConfigureVmRequest(bc, x) {
@@ -1101,7 +1117,7 @@ export function writeConfigureVmRequest(bc, x) {
     write20(bc, x.packages);
     bare.writeString(bc, x.packagesMountAt);
     write6(bc, x.bootstrapCommands);
-    write6(bc, x.toolShimCommands);
+    write6(bc, x.bindingShimCommands);
 }
 export function readRegisteredHostCallbackExample(bc) {
     return {
@@ -1466,6 +1482,14 @@ export function writeGuestKernelCallRequest(bc, x) {
     bare.writeString(bc, x.operation);
     bare.writeData(bc, x.payload);
 }
+export function readSnapshotRootFilesystemRequest(bc) {
+    return {
+        maxBytes: bare.readU64(bc),
+    };
+}
+export function writeSnapshotRootFilesystemRequest(bc, x) {
+    bare.writeU64(bc, x.maxBytes);
+}
 function read24(bc) {
     return bare.readBool(bc) ? readGuestRuntimeKind(bc) : null;
 }
@@ -1506,6 +1530,761 @@ export function writeExecuteRequest(bc, x) {
     write0(bc, x.cwd);
     write25(bc, x.wasmPermissionTier);
 }
+/**
+ * First-class execution lifecycle. The legacy process request above remains an
+ * internal kernel transport while clients migrate in lockstep to these semantic
+ * operations; language/package command construction belongs to the sidecar.
+ */
+export var ExecutionState;
+(function (ExecutionState) {
+    ExecutionState["Creating"] = "Creating";
+    ExecutionState["Idle"] = "Idle";
+    ExecutionState["Running"] = "Running";
+    ExecutionState["Resetting"] = "Resetting";
+    ExecutionState["Deleting"] = "Deleting";
+    ExecutionState["Failed"] = "Failed";
+})(ExecutionState || (ExecutionState = {}));
+export function readExecutionState(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return ExecutionState.Creating;
+        case 1:
+            return ExecutionState.Idle;
+        case 2:
+            return ExecutionState.Running;
+        case 3:
+            return ExecutionState.Resetting;
+        case 4:
+            return ExecutionState.Deleting;
+        case 5:
+            return ExecutionState.Failed;
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeExecutionState(bc, x) {
+    switch (x) {
+        case ExecutionState.Creating: {
+            bare.writeU8(bc, 0);
+            break;
+        }
+        case ExecutionState.Idle: {
+            bare.writeU8(bc, 1);
+            break;
+        }
+        case ExecutionState.Running: {
+            bare.writeU8(bc, 2);
+            break;
+        }
+        case ExecutionState.Resetting: {
+            bare.writeU8(bc, 3);
+            break;
+        }
+        case ExecutionState.Deleting: {
+            bare.writeU8(bc, 4);
+            break;
+        }
+        case ExecutionState.Failed: {
+            bare.writeU8(bc, 5);
+            break;
+        }
+    }
+}
+export var ExecutionOutcome;
+(function (ExecutionOutcome) {
+    ExecutionOutcome["Succeeded"] = "Succeeded";
+    ExecutionOutcome["Failed"] = "Failed";
+    ExecutionOutcome["Cancelled"] = "Cancelled";
+    ExecutionOutcome["TimedOut"] = "TimedOut";
+})(ExecutionOutcome || (ExecutionOutcome = {}));
+export function readExecutionOutcome(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return ExecutionOutcome.Succeeded;
+        case 1:
+            return ExecutionOutcome.Failed;
+        case 2:
+            return ExecutionOutcome.Cancelled;
+        case 3:
+            return ExecutionOutcome.TimedOut;
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeExecutionOutcome(bc, x) {
+    switch (x) {
+        case ExecutionOutcome.Succeeded: {
+            bare.writeU8(bc, 0);
+            break;
+        }
+        case ExecutionOutcome.Failed: {
+            bare.writeU8(bc, 1);
+            break;
+        }
+        case ExecutionOutcome.Cancelled: {
+            bare.writeU8(bc, 2);
+            break;
+        }
+        case ExecutionOutcome.TimedOut: {
+            bare.writeU8(bc, 3);
+            break;
+        }
+    }
+}
+export var RetainedExecutionLanguage;
+(function (RetainedExecutionLanguage) {
+    RetainedExecutionLanguage["JavaScript"] = "JavaScript";
+    RetainedExecutionLanguage["Python"] = "Python";
+})(RetainedExecutionLanguage || (RetainedExecutionLanguage = {}));
+export function readRetainedExecutionLanguage(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return RetainedExecutionLanguage.JavaScript;
+        case 1:
+            return RetainedExecutionLanguage.Python;
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeRetainedExecutionLanguage(bc, x) {
+    switch (x) {
+        case RetainedExecutionLanguage.JavaScript: {
+            bare.writeU8(bc, 0);
+            break;
+        }
+        case RetainedExecutionLanguage.Python: {
+            bare.writeU8(bc, 1);
+            break;
+        }
+    }
+}
+export var ExecutionStreamChannel;
+(function (ExecutionStreamChannel) {
+    ExecutionStreamChannel["Stdout"] = "Stdout";
+    ExecutionStreamChannel["Stderr"] = "Stderr";
+    ExecutionStreamChannel["Pty"] = "Pty";
+})(ExecutionStreamChannel || (ExecutionStreamChannel = {}));
+export function readExecutionStreamChannel(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return ExecutionStreamChannel.Stdout;
+        case 1:
+            return ExecutionStreamChannel.Stderr;
+        case 2:
+            return ExecutionStreamChannel.Pty;
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeExecutionStreamChannel(bc, x) {
+    switch (x) {
+        case ExecutionStreamChannel.Stdout: {
+            bare.writeU8(bc, 0);
+            break;
+        }
+        case ExecutionStreamChannel.Stderr: {
+            bare.writeU8(bc, 1);
+            break;
+        }
+        case ExecutionStreamChannel.Pty: {
+            bare.writeU8(bc, 2);
+            break;
+        }
+    }
+}
+export var JavaScriptModuleFormat;
+(function (JavaScriptModuleFormat) {
+    JavaScriptModuleFormat["Module"] = "Module";
+    JavaScriptModuleFormat["CommonJs"] = "CommonJs";
+})(JavaScriptModuleFormat || (JavaScriptModuleFormat = {}));
+export function readJavaScriptModuleFormat(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return JavaScriptModuleFormat.Module;
+        case 1:
+            return JavaScriptModuleFormat.CommonJs;
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeJavaScriptModuleFormat(bc, x) {
+    switch (x) {
+        case JavaScriptModuleFormat.Module: {
+            bare.writeU8(bc, 0);
+            break;
+        }
+        case JavaScriptModuleFormat.CommonJs: {
+            bare.writeU8(bc, 1);
+            break;
+        }
+    }
+}
+export function readExecutionIdentityOptions(bc) {
+    return {
+        contextId: read0(bc),
+    };
+}
+export function writeExecutionIdentityOptions(bc, x) {
+    write0(bc, x.contextId);
+}
+function read26(bc) {
+    return bare.readBool(bc) ? bare.readU16(bc) : null;
+}
+function write26(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        bare.writeU16(bc, x);
+    }
+}
+export function readExecutionPtyOptions(bc) {
+    return {
+        cols: read26(bc),
+        rows: read26(bc),
+    };
+}
+export function writeExecutionPtyOptions(bc, x) {
+    write26(bc, x.cols);
+    write26(bc, x.rows);
+}
+export var ExecutionOutputCapture;
+(function (ExecutionOutputCapture) {
+    ExecutionOutputCapture["None"] = "None";
+    ExecutionOutputCapture["Stderr"] = "Stderr";
+    ExecutionOutputCapture["All"] = "All";
+})(ExecutionOutputCapture || (ExecutionOutputCapture = {}));
+export function readExecutionOutputCapture(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return ExecutionOutputCapture.None;
+        case 1:
+            return ExecutionOutputCapture.Stderr;
+        case 2:
+            return ExecutionOutputCapture.All;
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeExecutionOutputCapture(bc, x) {
+    switch (x) {
+        case ExecutionOutputCapture.None: {
+            bare.writeU8(bc, 0);
+            break;
+        }
+        case ExecutionOutputCapture.Stderr: {
+            bare.writeU8(bc, 1);
+            break;
+        }
+        case ExecutionOutputCapture.All: {
+            bare.writeU8(bc, 2);
+            break;
+        }
+    }
+}
+function read27(bc) {
+    return bare.readBool(bc) ? readExecutionOutputCapture(bc) : null;
+}
+function write27(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        writeExecutionOutputCapture(bc, x);
+    }
+}
+function read28(bc) {
+    return bare.readBool(bc) ? bare.readBool(bc) : null;
+}
+function write28(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        bare.writeBool(bc, x);
+    }
+}
+export function readExecutionOutputOptions(bc) {
+    return {
+        capture: read27(bc),
+        retainEvents: read28(bc),
+    };
+}
+export function writeExecutionOutputOptions(bc, x) {
+    write27(bc, x.capture);
+    write28(bc, x.retainEvents);
+}
+function read29(bc) {
+    return bare.readBool(bc) ? read1(bc) : null;
+}
+function write29(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        write1(bc, x);
+    }
+}
+function read30(bc) {
+    return bare.readBool(bc) ? bare.readData(bc) : null;
+}
+function write30(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        bare.writeData(bc, x);
+    }
+}
+function read31(bc) {
+    return bare.readBool(bc) ? readExecutionPtyOptions(bc) : null;
+}
+function write31(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        writeExecutionPtyOptions(bc, x);
+    }
+}
+export function readProcessExecutionOptions(bc) {
+    return {
+        identity: readExecutionIdentityOptions(bc),
+        output: readExecutionOutputOptions(bc),
+        operationId: read0(bc),
+        background: read28(bc),
+        cwd: read0(bc),
+        env: read29(bc),
+        args: read6(bc),
+        stdin: read30(bc),
+        timeoutMs: read21(bc),
+        pty: read31(bc),
+    };
+}
+export function writeProcessExecutionOptions(bc, x) {
+    writeExecutionIdentityOptions(bc, x.identity);
+    writeExecutionOutputOptions(bc, x.output);
+    write0(bc, x.operationId);
+    write28(bc, x.background);
+    write0(bc, x.cwd);
+    write29(bc, x.env);
+    write6(bc, x.args);
+    write30(bc, x.stdin);
+    write21(bc, x.timeoutMs);
+    write31(bc, x.pty);
+}
+export function readShellExecutionRequest(bc) {
+    return {
+        process: readProcessExecutionOptions(bc),
+        command: bare.readString(bc),
+    };
+}
+export function writeShellExecutionRequest(bc, x) {
+    writeProcessExecutionOptions(bc, x.process);
+    bare.writeString(bc, x.command);
+}
+export function readArgvExecutionRequest(bc) {
+    return {
+        process: readProcessExecutionOptions(bc),
+        command: bare.readString(bc),
+    };
+}
+export function writeArgvExecutionRequest(bc, x) {
+    writeProcessExecutionOptions(bc, x.process);
+    bare.writeString(bc, x.command);
+}
+function read32(bc) {
+    return bare.readBool(bc) ? readJavaScriptModuleFormat(bc) : null;
+}
+function write32(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        writeJavaScriptModuleFormat(bc, x);
+    }
+}
+function read33(bc) {
+    return bare.readBool(bc) ? readJsonUtf8(bc) : null;
+}
+function write33(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        writeJsonUtf8(bc, x);
+    }
+}
+export function readJavaScriptExecutionRequest(bc) {
+    return {
+        process: readProcessExecutionOptions(bc),
+        source: bare.readString(bc),
+        format: read32(bc),
+        filePath: read0(bc),
+        inputs: read33(bc),
+    };
+}
+export function writeJavaScriptExecutionRequest(bc, x) {
+    writeProcessExecutionOptions(bc, x.process);
+    bare.writeString(bc, x.source);
+    write32(bc, x.format);
+    write0(bc, x.filePath);
+    write33(bc, x.inputs);
+}
+export function readJavaScriptEvaluationRequest(bc) {
+    return {
+        process: readProcessExecutionOptions(bc),
+        expression: bare.readString(bc),
+        format: read32(bc),
+        filePath: read0(bc),
+        inputs: read33(bc),
+    };
+}
+export function writeJavaScriptEvaluationRequest(bc, x) {
+    writeProcessExecutionOptions(bc, x.process);
+    bare.writeString(bc, x.expression);
+    write32(bc, x.format);
+    write0(bc, x.filePath);
+    write33(bc, x.inputs);
+}
+export function readJavaScriptFileExecutionRequest(bc) {
+    return {
+        process: readProcessExecutionOptions(bc),
+        path: bare.readString(bc),
+    };
+}
+export function writeJavaScriptFileExecutionRequest(bc, x) {
+    writeProcessExecutionOptions(bc, x.process);
+    bare.writeString(bc, x.path);
+}
+export function readTypeScriptExecutionRequest(bc) {
+    return {
+        process: readProcessExecutionOptions(bc),
+        source: bare.readString(bc),
+        filePath: read0(bc),
+        tsconfigPath: read0(bc),
+        compilerOptions: read33(bc),
+        inputs: read33(bc),
+    };
+}
+export function writeTypeScriptExecutionRequest(bc, x) {
+    writeProcessExecutionOptions(bc, x.process);
+    bare.writeString(bc, x.source);
+    write0(bc, x.filePath);
+    write0(bc, x.tsconfigPath);
+    write33(bc, x.compilerOptions);
+    write33(bc, x.inputs);
+}
+export function readTypeScriptEvaluationRequest(bc) {
+    return {
+        process: readProcessExecutionOptions(bc),
+        expression: bare.readString(bc),
+        filePath: read0(bc),
+        tsconfigPath: read0(bc),
+        compilerOptions: read33(bc),
+        inputs: read33(bc),
+    };
+}
+export function writeTypeScriptEvaluationRequest(bc, x) {
+    writeProcessExecutionOptions(bc, x.process);
+    bare.writeString(bc, x.expression);
+    write0(bc, x.filePath);
+    write0(bc, x.tsconfigPath);
+    write33(bc, x.compilerOptions);
+    write33(bc, x.inputs);
+}
+export function readTypeScriptFileExecutionRequest(bc) {
+    return {
+        process: readProcessExecutionOptions(bc),
+        path: bare.readString(bc),
+        tsconfigPath: read0(bc),
+        compilerOptions: read33(bc),
+    };
+}
+export function writeTypeScriptFileExecutionRequest(bc, x) {
+    writeProcessExecutionOptions(bc, x.process);
+    bare.writeString(bc, x.path);
+    write0(bc, x.tsconfigPath);
+    write33(bc, x.compilerOptions);
+}
+export function readTypeScriptCheckRequest(bc) {
+    return {
+        identity: readExecutionIdentityOptions(bc),
+        output: readExecutionOutputOptions(bc),
+        source: bare.readString(bc),
+        cwd: read0(bc),
+        filePath: read0(bc),
+        tsconfigPath: read0(bc),
+        compilerOptions: read33(bc),
+        timeoutMs: read21(bc),
+    };
+}
+export function writeTypeScriptCheckRequest(bc, x) {
+    writeExecutionIdentityOptions(bc, x.identity);
+    writeExecutionOutputOptions(bc, x.output);
+    bare.writeString(bc, x.source);
+    write0(bc, x.cwd);
+    write0(bc, x.filePath);
+    write0(bc, x.tsconfigPath);
+    write33(bc, x.compilerOptions);
+    write21(bc, x.timeoutMs);
+}
+export function readTypeScriptProjectCheckRequest(bc) {
+    return {
+        identity: readExecutionIdentityOptions(bc),
+        output: readExecutionOutputOptions(bc),
+        cwd: read0(bc),
+        tsconfigPath: read0(bc),
+        timeoutMs: read21(bc),
+    };
+}
+export function writeTypeScriptProjectCheckRequest(bc, x) {
+    writeExecutionIdentityOptions(bc, x.identity);
+    writeExecutionOutputOptions(bc, x.output);
+    write0(bc, x.cwd);
+    write0(bc, x.tsconfigPath);
+    write21(bc, x.timeoutMs);
+}
+export function readNpmProjectInstallRequest(bc) {
+    return {
+        identity: readExecutionIdentityOptions(bc),
+        output: readExecutionOutputOptions(bc),
+        cwd: read0(bc),
+        env: read29(bc),
+        timeoutMs: read21(bc),
+        frozen: read28(bc),
+    };
+}
+export function writeNpmProjectInstallRequest(bc, x) {
+    writeExecutionIdentityOptions(bc, x.identity);
+    writeExecutionOutputOptions(bc, x.output);
+    write0(bc, x.cwd);
+    write29(bc, x.env);
+    write21(bc, x.timeoutMs);
+    write28(bc, x.frozen);
+}
+export function readNpmPackageInstallRequest(bc) {
+    return {
+        identity: readExecutionIdentityOptions(bc),
+        output: readExecutionOutputOptions(bc),
+        cwd: read0(bc),
+        env: read29(bc),
+        timeoutMs: read21(bc),
+        packages: read6(bc),
+        dev: read28(bc),
+        global: read28(bc),
+    };
+}
+export function writeNpmPackageInstallRequest(bc, x) {
+    writeExecutionIdentityOptions(bc, x.identity);
+    writeExecutionOutputOptions(bc, x.output);
+    write0(bc, x.cwd);
+    write29(bc, x.env);
+    write21(bc, x.timeoutMs);
+    write6(bc, x.packages);
+    write28(bc, x.dev);
+    write28(bc, x.global);
+}
+export function readNpmScriptExecutionRequest(bc) {
+    return {
+        process: readProcessExecutionOptions(bc),
+        script: bare.readString(bc),
+    };
+}
+export function writeNpmScriptExecutionRequest(bc, x) {
+    writeProcessExecutionOptions(bc, x.process);
+    bare.writeString(bc, x.script);
+}
+export function readNpmPackageExecutionRequest(bc) {
+    return {
+        process: readProcessExecutionOptions(bc),
+        packageSpec: bare.readString(bc),
+        binary: read0(bc),
+    };
+}
+export function writeNpmPackageExecutionRequest(bc, x) {
+    writeProcessExecutionOptions(bc, x.process);
+    bare.writeString(bc, x.packageSpec);
+    write0(bc, x.binary);
+}
+export function readPythonExecutionRequest(bc) {
+    return {
+        process: readProcessExecutionOptions(bc),
+        source: bare.readString(bc),
+        inputs: read33(bc),
+    };
+}
+export function writePythonExecutionRequest(bc, x) {
+    writeProcessExecutionOptions(bc, x.process);
+    bare.writeString(bc, x.source);
+    write33(bc, x.inputs);
+}
+export function readPythonEvaluationRequest(bc) {
+    return {
+        process: readProcessExecutionOptions(bc),
+        expression: bare.readString(bc),
+        inputs: read33(bc),
+    };
+}
+export function writePythonEvaluationRequest(bc, x) {
+    writeProcessExecutionOptions(bc, x.process);
+    bare.writeString(bc, x.expression);
+    write33(bc, x.inputs);
+}
+export function readPythonFileExecutionRequest(bc) {
+    return {
+        process: readProcessExecutionOptions(bc),
+        path: bare.readString(bc),
+    };
+}
+export function writePythonFileExecutionRequest(bc, x) {
+    writeProcessExecutionOptions(bc, x.process);
+    bare.writeString(bc, x.path);
+}
+export function readPythonModuleExecutionRequest(bc) {
+    return {
+        process: readProcessExecutionOptions(bc),
+        module: bare.readString(bc),
+    };
+}
+export function writePythonModuleExecutionRequest(bc, x) {
+    writeProcessExecutionOptions(bc, x.process);
+    bare.writeString(bc, x.module);
+}
+export function readPythonInstallRequest(bc) {
+    return {
+        identity: readExecutionIdentityOptions(bc),
+        output: readExecutionOutputOptions(bc),
+        cwd: read0(bc),
+        env: read29(bc),
+        timeoutMs: read21(bc),
+        packages: read6(bc),
+        upgrade: read28(bc),
+        requirementsFile: read0(bc),
+        indexUrl: read0(bc),
+        extraIndexUrls: read6(bc),
+    };
+}
+export function writePythonInstallRequest(bc, x) {
+    writeExecutionIdentityOptions(bc, x.identity);
+    writeExecutionOutputOptions(bc, x.output);
+    write0(bc, x.cwd);
+    write29(bc, x.env);
+    write21(bc, x.timeoutMs);
+    write6(bc, x.packages);
+    write28(bc, x.upgrade);
+    write0(bc, x.requirementsFile);
+    write0(bc, x.indexUrl);
+    write6(bc, x.extraIndexUrls);
+}
+export function readCreateContextRequest(bc) {
+    return {
+        contextId: bare.readString(bc),
+    };
+}
+export function writeCreateContextRequest(bc, x) {
+    bare.writeString(bc, x.contextId);
+}
+export function readGetExecutionRequest(bc) {
+    return {
+        executionId: bare.readString(bc),
+    };
+}
+export function writeGetExecutionRequest(bc, x) {
+    bare.writeString(bc, x.executionId);
+}
+export function readWaitExecutionRequest(bc) {
+    return {
+        executionId: bare.readString(bc),
+    };
+}
+export function writeWaitExecutionRequest(bc, x) {
+    bare.writeString(bc, x.executionId);
+}
+export function readCancelExecutionRequest(bc) {
+    return {
+        executionId: bare.readString(bc),
+    };
+}
+export function writeCancelExecutionRequest(bc, x) {
+    bare.writeString(bc, x.executionId);
+}
+export function readSignalExecutionRequest(bc) {
+    return {
+        executionId: bare.readString(bc),
+        signal: bare.readString(bc),
+    };
+}
+export function writeSignalExecutionRequest(bc, x) {
+    bare.writeString(bc, x.executionId);
+    bare.writeString(bc, x.signal);
+}
+export function readResetExecutionRequest(bc) {
+    return {
+        executionId: bare.readString(bc),
+    };
+}
+export function writeResetExecutionRequest(bc, x) {
+    bare.writeString(bc, x.executionId);
+}
+export function readDeleteExecutionRequest(bc) {
+    return {
+        executionId: bare.readString(bc),
+    };
+}
+export function writeDeleteExecutionRequest(bc, x) {
+    bare.writeString(bc, x.executionId);
+}
+export function readWriteExecutionStdinRequest(bc) {
+    return {
+        executionId: bare.readString(bc),
+        chunk: bare.readData(bc),
+    };
+}
+export function writeWriteExecutionStdinRequest(bc, x) {
+    bare.writeString(bc, x.executionId);
+    bare.writeData(bc, x.chunk);
+}
+export function readCloseExecutionStdinRequest(bc) {
+    return {
+        executionId: bare.readString(bc),
+    };
+}
+export function writeCloseExecutionStdinRequest(bc, x) {
+    bare.writeString(bc, x.executionId);
+}
+export function readResizeExecutionPtyRequest(bc) {
+    return {
+        executionId: bare.readString(bc),
+        cols: bare.readU16(bc),
+        rows: bare.readU16(bc),
+    };
+}
+export function writeResizeExecutionPtyRequest(bc, x) {
+    bare.writeString(bc, x.executionId);
+    bare.writeU16(bc, x.cols);
+    bare.writeU16(bc, x.rows);
+}
+export function readReadExecutionOutputRequest(bc) {
+    return {
+        executionId: bare.readString(bc),
+        cursor: read0(bc),
+        limit: read2(bc),
+    };
+}
+export function writeReadExecutionOutputRequest(bc, x) {
+    bare.writeString(bc, x.executionId);
+    write0(bc, x.cursor);
+    write2(bc, x.limit);
+}
 export function readWriteStdinRequest(bc) {
     return {
         processId: bare.readString(bc),
@@ -1546,15 +2325,6 @@ export function writeKillProcessRequest(bc, x) {
     bare.writeString(bc, x.processId);
     bare.writeString(bc, x.signal);
 }
-function read26(bc) {
-    return bare.readBool(bc) ? bare.readU16(bc) : null;
-}
-function write26(bc, x) {
-    bare.writeBool(bc, x != null);
-    if (x != null) {
-        bare.writeU16(bc, x);
-    }
-}
 export function readFindListenerRequest(bc) {
     return {
         host: read0(bc),
@@ -1688,6 +2458,10 @@ export function readVmFetchRequest(bc) {
         path: bare.readString(bc),
         headersJson: bare.readString(bc),
         body: read0(bc),
+        bodyBase64: read0(bc),
+        streamOperation: read0(bc),
+        streamId: read0(bc),
+        maxBytes: read2(bc),
     };
 }
 export function writeVmFetchRequest(bc, x) {
@@ -1696,6 +2470,10 @@ export function writeVmFetchRequest(bc, x) {
     bare.writeString(bc, x.path);
     bare.writeString(bc, x.headersJson);
     write0(bc, x.body);
+    write0(bc, x.bodyBase64);
+    write0(bc, x.streamOperation);
+    write0(bc, x.streamId);
+    write2(bc, x.maxBytes);
 }
 export function readRequestPayload(bc) {
     const offset = bc.offset;
@@ -1728,7 +2506,7 @@ export function readRequestPayload(bc) {
         case 12:
             return { tag: "GuestFilesystemCallRequest", val: readGuestFilesystemCallRequest(bc) };
         case 13:
-            return { tag: "SnapshotRootFilesystemRequest", val: null };
+            return { tag: "SnapshotRootFilesystemRequest", val: readSnapshotRootFilesystemRequest(bc) };
         case 14:
             return { tag: "ExecuteRequest", val: readExecuteRequest(bc) };
         case 15:
@@ -1767,6 +2545,70 @@ export function readRequestPayload(bc) {
             return { tag: "LinkPackageRequest", val: readLinkPackageRequest(bc) };
         case 32:
             return { tag: "ProvidedCommandsRequest", val: null };
+        case 33:
+            return { tag: "ListMountsRequest", val: null };
+        case 34:
+            return { tag: "ShellExecutionRequest", val: readShellExecutionRequest(bc) };
+        case 35:
+            return { tag: "ArgvExecutionRequest", val: readArgvExecutionRequest(bc) };
+        case 36:
+            return { tag: "JavaScriptExecutionRequest", val: readJavaScriptExecutionRequest(bc) };
+        case 37:
+            return { tag: "JavaScriptEvaluationRequest", val: readJavaScriptEvaluationRequest(bc) };
+        case 38:
+            return { tag: "JavaScriptFileExecutionRequest", val: readJavaScriptFileExecutionRequest(bc) };
+        case 39:
+            return { tag: "TypeScriptExecutionRequest", val: readTypeScriptExecutionRequest(bc) };
+        case 40:
+            return { tag: "TypeScriptEvaluationRequest", val: readTypeScriptEvaluationRequest(bc) };
+        case 41:
+            return { tag: "TypeScriptFileExecutionRequest", val: readTypeScriptFileExecutionRequest(bc) };
+        case 42:
+            return { tag: "TypeScriptCheckRequest", val: readTypeScriptCheckRequest(bc) };
+        case 43:
+            return { tag: "TypeScriptProjectCheckRequest", val: readTypeScriptProjectCheckRequest(bc) };
+        case 44:
+            return { tag: "NpmProjectInstallRequest", val: readNpmProjectInstallRequest(bc) };
+        case 45:
+            return { tag: "NpmPackageInstallRequest", val: readNpmPackageInstallRequest(bc) };
+        case 46:
+            return { tag: "NpmScriptExecutionRequest", val: readNpmScriptExecutionRequest(bc) };
+        case 47:
+            return { tag: "NpmPackageExecutionRequest", val: readNpmPackageExecutionRequest(bc) };
+        case 48:
+            return { tag: "PythonExecutionRequest", val: readPythonExecutionRequest(bc) };
+        case 49:
+            return { tag: "PythonEvaluationRequest", val: readPythonEvaluationRequest(bc) };
+        case 50:
+            return { tag: "PythonFileExecutionRequest", val: readPythonFileExecutionRequest(bc) };
+        case 51:
+            return { tag: "PythonModuleExecutionRequest", val: readPythonModuleExecutionRequest(bc) };
+        case 52:
+            return { tag: "PythonInstallRequest", val: readPythonInstallRequest(bc) };
+        case 53:
+            return { tag: "CreateContextRequest", val: readCreateContextRequest(bc) };
+        case 54:
+            return { tag: "GetExecutionRequest", val: readGetExecutionRequest(bc) };
+        case 55:
+            return { tag: "ListExecutionsRequest", val: null };
+        case 56:
+            return { tag: "WaitExecutionRequest", val: readWaitExecutionRequest(bc) };
+        case 57:
+            return { tag: "CancelExecutionRequest", val: readCancelExecutionRequest(bc) };
+        case 58:
+            return { tag: "SignalExecutionRequest", val: readSignalExecutionRequest(bc) };
+        case 59:
+            return { tag: "ResetExecutionRequest", val: readResetExecutionRequest(bc) };
+        case 60:
+            return { tag: "DeleteExecutionRequest", val: readDeleteExecutionRequest(bc) };
+        case 61:
+            return { tag: "WriteExecutionStdinRequest", val: readWriteExecutionStdinRequest(bc) };
+        case 62:
+            return { tag: "CloseExecutionStdinRequest", val: readCloseExecutionStdinRequest(bc) };
+        case 63:
+            return { tag: "ResizeExecutionPtyRequest", val: readResizeExecutionPtyRequest(bc) };
+        case 64:
+            return { tag: "ReadExecutionOutputRequest", val: readReadExecutionOutputRequest(bc) };
         default: {
             bc.offset = offset;
             throw new bare.BareError(offset, "invalid tag");
@@ -1841,6 +2683,7 @@ export function writeRequestPayload(bc, x) {
         }
         case "SnapshotRootFilesystemRequest": {
             bare.writeU8(bc, 13);
+            writeSnapshotRootFilesystemRequest(bc, x.val);
             break;
         }
         case "ExecuteRequest": {
@@ -1925,13 +2768,171 @@ export function writeRequestPayload(bc, x) {
             bare.writeU8(bc, 30);
             break;
         }
-        case "LinkPackageRequest": {
-            bare.writeU8(bc, 31);
-            writeLinkPackageRequest(bc, x.val);
+        case "LinkPackageRequest": {
+            bare.writeU8(bc, 31);
+            writeLinkPackageRequest(bc, x.val);
+            break;
+        }
+        case "ProvidedCommandsRequest": {
+            bare.writeU8(bc, 32);
+            break;
+        }
+        case "ListMountsRequest": {
+            bare.writeU8(bc, 33);
+            break;
+        }
+        case "ShellExecutionRequest": {
+            bare.writeU8(bc, 34);
+            writeShellExecutionRequest(bc, x.val);
+            break;
+        }
+        case "ArgvExecutionRequest": {
+            bare.writeU8(bc, 35);
+            writeArgvExecutionRequest(bc, x.val);
+            break;
+        }
+        case "JavaScriptExecutionRequest": {
+            bare.writeU8(bc, 36);
+            writeJavaScriptExecutionRequest(bc, x.val);
+            break;
+        }
+        case "JavaScriptEvaluationRequest": {
+            bare.writeU8(bc, 37);
+            writeJavaScriptEvaluationRequest(bc, x.val);
+            break;
+        }
+        case "JavaScriptFileExecutionRequest": {
+            bare.writeU8(bc, 38);
+            writeJavaScriptFileExecutionRequest(bc, x.val);
+            break;
+        }
+        case "TypeScriptExecutionRequest": {
+            bare.writeU8(bc, 39);
+            writeTypeScriptExecutionRequest(bc, x.val);
+            break;
+        }
+        case "TypeScriptEvaluationRequest": {
+            bare.writeU8(bc, 40);
+            writeTypeScriptEvaluationRequest(bc, x.val);
+            break;
+        }
+        case "TypeScriptFileExecutionRequest": {
+            bare.writeU8(bc, 41);
+            writeTypeScriptFileExecutionRequest(bc, x.val);
+            break;
+        }
+        case "TypeScriptCheckRequest": {
+            bare.writeU8(bc, 42);
+            writeTypeScriptCheckRequest(bc, x.val);
+            break;
+        }
+        case "TypeScriptProjectCheckRequest": {
+            bare.writeU8(bc, 43);
+            writeTypeScriptProjectCheckRequest(bc, x.val);
+            break;
+        }
+        case "NpmProjectInstallRequest": {
+            bare.writeU8(bc, 44);
+            writeNpmProjectInstallRequest(bc, x.val);
+            break;
+        }
+        case "NpmPackageInstallRequest": {
+            bare.writeU8(bc, 45);
+            writeNpmPackageInstallRequest(bc, x.val);
+            break;
+        }
+        case "NpmScriptExecutionRequest": {
+            bare.writeU8(bc, 46);
+            writeNpmScriptExecutionRequest(bc, x.val);
+            break;
+        }
+        case "NpmPackageExecutionRequest": {
+            bare.writeU8(bc, 47);
+            writeNpmPackageExecutionRequest(bc, x.val);
+            break;
+        }
+        case "PythonExecutionRequest": {
+            bare.writeU8(bc, 48);
+            writePythonExecutionRequest(bc, x.val);
+            break;
+        }
+        case "PythonEvaluationRequest": {
+            bare.writeU8(bc, 49);
+            writePythonEvaluationRequest(bc, x.val);
+            break;
+        }
+        case "PythonFileExecutionRequest": {
+            bare.writeU8(bc, 50);
+            writePythonFileExecutionRequest(bc, x.val);
+            break;
+        }
+        case "PythonModuleExecutionRequest": {
+            bare.writeU8(bc, 51);
+            writePythonModuleExecutionRequest(bc, x.val);
+            break;
+        }
+        case "PythonInstallRequest": {
+            bare.writeU8(bc, 52);
+            writePythonInstallRequest(bc, x.val);
+            break;
+        }
+        case "CreateContextRequest": {
+            bare.writeU8(bc, 53);
+            writeCreateContextRequest(bc, x.val);
+            break;
+        }
+        case "GetExecutionRequest": {
+            bare.writeU8(bc, 54);
+            writeGetExecutionRequest(bc, x.val);
+            break;
+        }
+        case "ListExecutionsRequest": {
+            bare.writeU8(bc, 55);
+            break;
+        }
+        case "WaitExecutionRequest": {
+            bare.writeU8(bc, 56);
+            writeWaitExecutionRequest(bc, x.val);
+            break;
+        }
+        case "CancelExecutionRequest": {
+            bare.writeU8(bc, 57);
+            writeCancelExecutionRequest(bc, x.val);
+            break;
+        }
+        case "SignalExecutionRequest": {
+            bare.writeU8(bc, 58);
+            writeSignalExecutionRequest(bc, x.val);
+            break;
+        }
+        case "ResetExecutionRequest": {
+            bare.writeU8(bc, 59);
+            writeResetExecutionRequest(bc, x.val);
+            break;
+        }
+        case "DeleteExecutionRequest": {
+            bare.writeU8(bc, 60);
+            writeDeleteExecutionRequest(bc, x.val);
+            break;
+        }
+        case "WriteExecutionStdinRequest": {
+            bare.writeU8(bc, 61);
+            writeWriteExecutionStdinRequest(bc, x.val);
+            break;
+        }
+        case "CloseExecutionStdinRequest": {
+            bare.writeU8(bc, 62);
+            writeCloseExecutionStdinRequest(bc, x.val);
+            break;
+        }
+        case "ResizeExecutionPtyRequest": {
+            bare.writeU8(bc, 63);
+            writeResizeExecutionPtyRequest(bc, x.val);
             break;
         }
-        case "ProvidedCommandsRequest": {
-            bare.writeU8(bc, 32);
+        case "ReadExecutionOutputRequest": {
+            bare.writeU8(bc, 64);
+            writeReadExecutionOutputRequest(bc, x.val);
             break;
         }
     }
@@ -2114,7 +3115,7 @@ export function writeGuestDirEntry(bc, x) {
     bare.writeBool(bc, x.isSymbolicLink);
     bare.writeU64(bc, x.size);
 }
-function read27(bc) {
+function read34(bc) {
     const len = bare.readUintSafe(bc);
     if (len === 0) {
         return [];
@@ -2125,48 +3126,39 @@ function read27(bc) {
     }
     return result;
 }
-function write27(bc, x) {
+function write34(bc, x) {
     bare.writeUintSafe(bc, x.length);
     for (let i = 0; i < x.length; i++) {
         writeGuestDirEntry(bc, x[i]);
     }
 }
-function read28(bc) {
-    return bare.readBool(bc) ? read27(bc) : null;
+function read35(bc) {
+    return bare.readBool(bc) ? read34(bc) : null;
 }
-function write28(bc, x) {
+function write35(bc, x) {
     bare.writeBool(bc, x != null);
     if (x != null) {
-        write27(bc, x);
+        write34(bc, x);
     }
 }
-function read29(bc) {
+function read36(bc) {
     return bare.readBool(bc) ? readGuestFilesystemStat(bc) : null;
 }
-function write29(bc, x) {
+function write36(bc, x) {
     bare.writeBool(bc, x != null);
     if (x != null) {
         writeGuestFilesystemStat(bc, x);
     }
 }
-function read30(bc) {
-    return bare.readBool(bc) ? bare.readBool(bc) : null;
-}
-function write30(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: read28(bc),
-        stat: read29(bc),
-        exists: read30(bc),
+        entries: read35(bc),
+        stat: read36(bc),
+        exists: read28(bc),
         target: read0(bc),
     };
 }
@@ -2175,9 +3167,9 @@ export function writeGuestFilesystemResultResponse(bc, x) {
     bare.writeString(bc, x.path);
     write0(bc, x.content);
     write3(bc, x.encoding);
-    write28(bc, x.entries);
-    write29(bc, x.stat);
-    write30(bc, x.exists);
+    write35(bc, x.entries);
+    write36(bc, x.stat);
+    write28(bc, x.exists);
     write0(bc, x.target);
 }
 export function readGuestKernelResultResponse(bc) {
@@ -2196,6 +3188,31 @@ export function readRootFilesystemSnapshotResponse(bc) {
 export function writeRootFilesystemSnapshotResponse(bc, x) {
     write4(bc, x.entries);
 }
+function read37(bc) {
+    const len = bare.readUintSafe(bc);
+    if (len === 0) {
+        return [];
+    }
+    const result = [readMountInfo(bc)];
+    for (let i = 1; i < len; i++) {
+        result[i] = readMountInfo(bc);
+    }
+    return result;
+}
+function write37(bc, x) {
+    bare.writeUintSafe(bc, x.length);
+    for (let i = 0; i < x.length; i++) {
+        writeMountInfo(bc, x[i]);
+    }
+}
+export function readListMountsResponse(bc) {
+    return {
+        mounts: read37(bc),
+    };
+}
+export function writeListMountsResponse(bc, x) {
+    write37(bc, x.mounts);
+}
 export function readProcessStartedResponse(bc) {
     return {
         processId: bare.readString(bc),
@@ -2282,10 +3299,10 @@ export function writeProcessSnapshotStatus(bc, x) {
         }
     }
 }
-function read31(bc) {
+function read38(bc) {
     return bare.readBool(bc) ? bare.readI32(bc) : null;
 }
-function write31(bc, x) {
+function write38(bc, x) {
     bare.writeBool(bc, x != null);
     if (x != null) {
         bare.writeI32(bc, x);
@@ -2303,7 +3320,7 @@ export function readProcessSnapshotEntry(bc) {
         args: read6(bc),
         cwd: bare.readString(bc),
         status: readProcessSnapshotStatus(bc),
-        exitCode: read31(bc),
+        exitCode: read38(bc),
     };
 }
 export function writeProcessSnapshotEntry(bc, x) {
@@ -2317,9 +3334,9 @@ export function writeProcessSnapshotEntry(bc, x) {
     write6(bc, x.args);
     bare.writeString(bc, x.cwd);
     writeProcessSnapshotStatus(bc, x.status);
-    write31(bc, x.exitCode);
+    write38(bc, x.exitCode);
 }
-function read32(bc) {
+function read39(bc) {
     const len = bare.readUintSafe(bc);
     if (len === 0) {
         return [];
@@ -2330,7 +3347,7 @@ function read32(bc) {
     }
     return result;
 }
-function write32(bc, x) {
+function write39(bc, x) {
     bare.writeUintSafe(bc, x.length);
     for (let i = 0; i < x.length; i++) {
         writeProcessSnapshotEntry(bc, x[i]);
@@ -2338,11 +3355,11 @@ function write32(bc, x) {
 }
 export function readProcessSnapshotResponse(bc) {
     return {
-        processes: read32(bc),
+        processes: read39(bc),
     };
 }
 export function writeProcessSnapshotResponse(bc, x) {
-    write32(bc, x.processes);
+    write39(bc, x.processes);
 }
 export function readQueueSnapshotEntry(bc) {
     return {
@@ -2362,7 +3379,7 @@ export function writeQueueSnapshotEntry(bc, x) {
     bare.writeU64(bc, x.capacity);
     bare.writeU64(bc, x.fillPercent);
 }
-function read33(bc) {
+function read40(bc) {
     const len = bare.readUintSafe(bc);
     if (len === 0) {
         return [];
@@ -2373,7 +3390,7 @@ function read33(bc) {
     }
     return result;
 }
-function write33(bc, x) {
+function write40(bc, x) {
     bare.writeUintSafe(bc, x.length);
     for (let i = 0; i < x.length; i++) {
         writeQueueSnapshotEntry(bc, x[i]);
@@ -2395,7 +3412,7 @@ export function readResourceSnapshotResponse(bc) {
         socketConnections: bare.readU64(bc),
         socketBufferedBytes: bare.readU64(bc),
         socketDatagramQueueLen: bare.readU64(bc),
-        queueSnapshots: read33(bc),
+        queueSnapshots: read40(bc),
     };
 }
 export function writeResourceSnapshotResponse(bc, x) {
@@ -2413,7 +3430,7 @@ export function writeResourceSnapshotResponse(bc, x) {
     bare.writeU64(bc, x.socketConnections);
     bare.writeU64(bc, x.socketBufferedBytes);
     bare.writeU64(bc, x.socketDatagramQueueLen);
-    write33(bc, x.queueSnapshots);
+    write40(bc, x.queueSnapshots);
 }
 export function readSocketStateEntry(bc) {
     return {
@@ -2429,10 +3446,10 @@ export function writeSocketStateEntry(bc, x) {
     write26(bc, x.port);
     write0(bc, x.path);
 }
-function read34(bc) {
+function read41(bc) {
     return bare.readBool(bc) ? readSocketStateEntry(bc) : null;
 }
-function write34(bc, x) {
+function write41(bc, x) {
     bare.writeBool(bc, x != null);
     if (x != null) {
         writeSocketStateEntry(bc, x);
@@ -2440,19 +3457,19 @@ function write34(bc, x) {
 }
 export function readListenerSnapshotResponse(bc) {
     return {
-        listener: read34(bc),
+        listener: read41(bc),
     };
 }
 export function writeListenerSnapshotResponse(bc, x) {
-    write34(bc, x.listener);
+    write41(bc, x.listener);
 }
 export function readBoundUdpSnapshotResponse(bc) {
     return {
-        socket: read34(bc),
+        socket: read41(bc),
     };
 }
 export function writeBoundUdpSnapshotResponse(bc, x) {
-    write34(bc, x.socket);
+    write41(bc, x.socket);
 }
 export var SignalDispositionAction;
 (function (SignalDispositionAction) {
@@ -2504,7 +3521,7 @@ export function writeSignalHandlerRegistration(bc, x) {
     bare.writeU32Array(bc, x.mask);
     bare.writeU32(bc, x.flags);
 }
-function read35(bc) {
+function read42(bc) {
     const len = bare.readUintSafe(bc);
     const result = new Map();
     for (let i = 0; i < len; i++) {
@@ -2518,7 +3535,7 @@ function read35(bc) {
     }
     return result;
 }
-function write35(bc, x) {
+function write42(bc, x) {
     bare.writeUintSafe(bc, x.size);
     for (const kv of x) {
         bare.writeU32(bc, kv[0]);
@@ -2528,12 +3545,12 @@ function write35(bc, x) {
 export function readSignalStateResponse(bc) {
     return {
         processId: bare.readString(bc),
-        handlers: read35(bc),
+        handlers: read42(bc),
     };
 }
 export function writeSignalStateResponse(bc, x) {
     bare.writeString(bc, x.processId);
-    write35(bc, x.handlers);
+    write42(bc, x.handlers);
 }
 export function readZombieTimerCountResponse(bc) {
     return {
@@ -2591,11 +3608,37 @@ export function readRejectedResponse(bc) {
     return {
         code: bare.readString(bc),
         message: bare.readString(bc),
+        limitName: read0(bc),
+        configuredLimit: read21(bc),
+        currentUsage: read21(bc),
+        requested: read21(bc),
+        unit: read0(bc),
+        scope: read0(bc),
+        vmId: read0(bc),
+        sessionGeneration: read21(bc),
+        capabilityId: read21(bc),
+        operation: read0(bc),
+        configurationPath: read0(bc),
+        retryable: read28(bc),
+        errno: read0(bc),
     };
 }
 export function writeRejectedResponse(bc, x) {
     bare.writeString(bc, x.code);
     bare.writeString(bc, x.message);
+    write0(bc, x.limitName);
+    write21(bc, x.configuredLimit);
+    write21(bc, x.currentUsage);
+    write21(bc, x.requested);
+    write0(bc, x.unit);
+    write0(bc, x.scope);
+    write0(bc, x.vmId);
+    write21(bc, x.sessionGeneration);
+    write21(bc, x.capabilityId);
+    write0(bc, x.operation);
+    write0(bc, x.configurationPath);
+    write28(bc, x.retryable);
+    write0(bc, x.errno);
 }
 export function readVmFetchResponse(bc) {
     return {
@@ -2605,6 +3648,285 @@ export function readVmFetchResponse(bc) {
 export function writeVmFetchResponse(bc, x) {
     bare.writeString(bc, x.responseJson);
 }
+function read43(bc) {
+    return bare.readBool(bc) ? readRetainedExecutionLanguage(bc) : null;
+}
+function write43(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        writeRetainedExecutionLanguage(bc, x);
+    }
+}
+function read44(bc) {
+    return bare.readBool(bc) ? readExecutionOutcome(bc) : null;
+}
+function write44(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        writeExecutionOutcome(bc, x);
+    }
+}
+export function readExecutionDescriptor(bc) {
+    return {
+        executionId: bare.readString(bc),
+        generation: bare.readU64(bc),
+        state: readExecutionState(bc),
+        retainedLanguage: read43(bc),
+        processId: read0(bc),
+        pid: read2(bc),
+        createdAtMs: bare.readU64(bc),
+        lastStartedAtMs: read21(bc),
+        lastCompletedAtMs: read21(bc),
+        lastOutcome: read44(bc),
+        lastExitCode: read38(bc),
+    };
+}
+export function writeExecutionDescriptor(bc, x) {
+    bare.writeString(bc, x.executionId);
+    bare.writeU64(bc, x.generation);
+    writeExecutionState(bc, x.state);
+    write43(bc, x.retainedLanguage);
+    write0(bc, x.processId);
+    write2(bc, x.pid);
+    bare.writeU64(bc, x.createdAtMs);
+    write21(bc, x.lastStartedAtMs);
+    write21(bc, x.lastCompletedAtMs);
+    write44(bc, x.lastOutcome);
+    write38(bc, x.lastExitCode);
+}
+export function readExecutionErrorData(bc) {
+    return {
+        code: bare.readString(bc),
+        name: bare.readString(bc),
+        message: bare.readString(bc),
+        stack: read0(bc),
+        details: read33(bc),
+    };
+}
+export function writeExecutionErrorData(bc, x) {
+    bare.writeString(bc, x.code);
+    bare.writeString(bc, x.name);
+    bare.writeString(bc, x.message);
+    write0(bc, x.stack);
+    write33(bc, x.details);
+}
+function read45(bc) {
+    return bare.readBool(bc) ? readExecutionDescriptor(bc) : null;
+}
+function write45(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        writeExecutionDescriptor(bc, x);
+    }
+}
+export function readExecutionAcceptedResponse(bc) {
+    return {
+        operationId: bare.readString(bc),
+        execution: read45(bc),
+    };
+}
+export function writeExecutionAcceptedResponse(bc, x) {
+    bare.writeString(bc, x.operationId);
+    write45(bc, x.execution);
+}
+function read46(bc) {
+    return bare.readBool(bc) ? readExecutionErrorData(bc) : null;
+}
+function write46(bc, x) {
+    bare.writeBool(bc, x != null);
+    if (x != null) {
+        writeExecutionErrorData(bc, x);
+    }
+}
+export function readExecutionCompletedResponse(bc) {
+    return {
+        execution: read45(bc),
+        outcome: readExecutionOutcome(bc),
+        exitCode: read38(bc),
+        error: read46(bc),
+        stdout: read30(bc),
+        stderr: read30(bc),
+        stdoutTruncated: read28(bc),
+        stderrTruncated: read28(bc),
+        evaluationValue: read33(bc),
+        typeScriptCheckResult: read33(bc),
+    };
+}
+export function writeExecutionCompletedResponse(bc, x) {
+    write45(bc, x.execution);
+    writeExecutionOutcome(bc, x.outcome);
+    write38(bc, x.exitCode);
+    write46(bc, x.error);
+    write30(bc, x.stdout);
+    write30(bc, x.stderr);
+    write28(bc, x.stdoutTruncated);
+    write28(bc, x.stderrTruncated);
+    write33(bc, x.evaluationValue);
+    write33(bc, x.typeScriptCheckResult);
+}
+export function readExecutionEvaluationResponse(bc) {
+    return {
+        result: readExecutionCompletedResponse(bc),
+        value: read33(bc),
+    };
+}
+export function writeExecutionEvaluationResponse(bc, x) {
+    writeExecutionCompletedResponse(bc, x.result);
+    write33(bc, x.value);
+}
+export function readTypeScriptDiagnostic(bc) {
+    return {
+        code: bare.readU32(bc),
+        category: bare.readString(bc),
+        message: bare.readString(bc),
+        filePath: read0(bc),
+        line: read2(bc),
+        column: read2(bc),
+    };
+}
+export function writeTypeScriptDiagnostic(bc, x) {
+    bare.writeU32(bc, x.code);
+    bare.writeString(bc, x.category);
+    bare.writeString(bc, x.message);
+    write0(bc, x.filePath);
+    write2(bc, x.line);
+    write2(bc, x.column);
+}
+function read47(bc) {
+    const len = bare.readUintSafe(bc);
+    if (len === 0) {
+        return [];
+    }
+    const result = [readTypeScriptDiagnostic(bc)];
+    for (let i = 1; i < len; i++) {
+        result[i] = readTypeScriptDiagnostic(bc);
+    }
+    return result;
+}
+function write47(bc, x) {
+    bare.writeUintSafe(bc, x.length);
+    for (let i = 0; i < x.length; i++) {
+        writeTypeScriptDiagnostic(bc, x[i]);
+    }
+}
+export function readTypeScriptCheckResponse(bc) {
+    return {
+        result: readExecutionCompletedResponse(bc),
+        hasErrors: read28(bc),
+        diagnostics: read47(bc),
+    };
+}
+export function writeTypeScriptCheckResponse(bc, x) {
+    writeExecutionCompletedResponse(bc, x.result);
+    write28(bc, x.hasErrors);
+    write47(bc, x.diagnostics);
+}
+export function readExecutionDescriptorResponse(bc) {
+    return {
+        execution: readExecutionDescriptor(bc),
+    };
+}
+export function writeExecutionDescriptorResponse(bc, x) {
+    writeExecutionDescriptor(bc, x.execution);
+}
+function read48(bc) {
+    const len = bare.readUintSafe(bc);
+    if (len === 0) {
+        return [];
+    }
+    const result = [readExecutionDescriptor(bc)];
+    for (let i = 1; i < len; i++) {
+        result[i] = readExecutionDescriptor(bc);
+    }
+    return result;
+}
+function write48(bc, x) {
+    bare.writeUintSafe(bc, x.length);
+    for (let i = 0; i < x.length; i++) {
+        writeExecutionDescriptor(bc, x[i]);
+    }
+}
+export function readExecutionListResponse(bc) {
+    return {
+        executions: read48(bc),
+    };
+}
+export function writeExecutionListResponse(bc, x) {
+    write48(bc, x.executions);
+}
+export function readExecutionDeletedResponse(bc) {
+    return {
+        executionId: bare.readString(bc),
+    };
+}
+export function writeExecutionDeletedResponse(bc, x) {
+    bare.writeString(bc, x.executionId);
+}
+export function readExecutionIoResponse(bc) {
+    return {
+        executionId: bare.readString(bc),
+        acceptedBytes: read21(bc),
+    };
+}
+export function writeExecutionIoResponse(bc, x) {
+    bare.writeString(bc, x.executionId);
+    write21(bc, x.acceptedBytes);
+}
+export function readExecutionOutputEvent(bc) {
+    return {
+        executionId: bare.readString(bc),
+        generation: bare.readU64(bc),
+        processId: read0(bc),
+        sequence: bare.readU64(bc),
+        channel: readExecutionStreamChannel(bc),
+        chunk: bare.readData(bc),
+        timestampMs: bare.readU64(bc),
+    };
+}
+export function writeExecutionOutputEvent(bc, x) {
+    bare.writeString(bc, x.executionId);
+    bare.writeU64(bc, x.generation);
+    write0(bc, x.processId);
+    bare.writeU64(bc, x.sequence);
+    writeExecutionStreamChannel(bc, x.channel);
+    bare.writeData(bc, x.chunk);
+    bare.writeU64(bc, x.timestampMs);
+}
+function read49(bc) {
+    const len = bare.readUintSafe(bc);
+    if (len === 0) {
+        return [];
+    }
+    const result = [readExecutionOutputEvent(bc)];
+    for (let i = 1; i < len; i++) {
+        result[i] = readExecutionOutputEvent(bc);
+    }
+    return result;
+}
+function write49(bc, x) {
+    bare.writeUintSafe(bc, x.length);
+    for (let i = 0; i < x.length; i++) {
+        writeExecutionOutputEvent(bc, x[i]);
+    }
+}
+export function readExecutionOutputPageResponse(bc) {
+    return {
+        executionId: bare.readString(bc),
+        generation: bare.readU64(bc),
+        events: read49(bc),
+        nextCursor: bare.readString(bc),
+        hasMore: bare.readBool(bc),
+        truncated: bare.readBool(bc),
+    };
+}
+export function writeExecutionOutputPageResponse(bc, x) {
+    bare.writeString(bc, x.executionId);
+    bare.writeU64(bc, x.generation);
+    write49(bc, x.events);
+    bare.writeString(bc, x.nextCursor);
+    bare.writeBool(bc, x.hasMore);
+    bare.writeBool(bc, x.truncated);
+}
 export function readResponsePayload(bc) {
     const offset = bc.offset;
     const tag = bare.readU8(bc);
@@ -2679,6 +4001,26 @@ export function readResponsePayload(bc) {
             return { tag: "PackageLinkedResponse", val: readPackageLinkedResponse(bc) };
         case 34:
             return { tag: "ProvidedCommandsResponse", val: readProvidedCommandsResponse(bc) };
+        case 35:
+            return { tag: "ListMountsResponse", val: readListMountsResponse(bc) };
+        case 36:
+            return { tag: "ExecutionAcceptedResponse", val: readExecutionAcceptedResponse(bc) };
+        case 37:
+            return { tag: "ExecutionCompletedResponse", val: readExecutionCompletedResponse(bc) };
+        case 38:
+            return { tag: "ExecutionEvaluationResponse", val: readExecutionEvaluationResponse(bc) };
+        case 39:
+            return { tag: "TypeScriptCheckResponse", val: readTypeScriptCheckResponse(bc) };
+        case 40:
+            return { tag: "ExecutionDescriptorResponse", val: readExecutionDescriptorResponse(bc) };
+        case 41:
+            return { tag: "ExecutionListResponse", val: readExecutionListResponse(bc) };
+        case 42:
+            return { tag: "ExecutionDeletedResponse", val: readExecutionDeletedResponse(bc) };
+        case 43:
+            return { tag: "ExecutionIoResponse", val: readExecutionIoResponse(bc) };
+        case 44:
+            return { tag: "ExecutionOutputPageResponse", val: readExecutionOutputPageResponse(bc) };
         default: {
             bc.offset = offset;
             throw new bare.BareError(offset, "invalid tag");
@@ -2862,6 +4204,56 @@ export function writeResponsePayload(bc, x) {
             writeProvidedCommandsResponse(bc, x.val);
             break;
         }
+        case "ListMountsResponse": {
+            bare.writeU8(bc, 35);
+            writeListMountsResponse(bc, x.val);
+            break;
+        }
+        case "ExecutionAcceptedResponse": {
+            bare.writeU8(bc, 36);
+            writeExecutionAcceptedResponse(bc, x.val);
+            break;
+        }
+        case "ExecutionCompletedResponse": {
+            bare.writeU8(bc, 37);
+            writeExecutionCompletedResponse(bc, x.val);
+            break;
+        }
+        case "ExecutionEvaluationResponse": {
+            bare.writeU8(bc, 38);
+            writeExecutionEvaluationResponse(bc, x.val);
+            break;
+        }
+        case "TypeScriptCheckResponse": {
+            bare.writeU8(bc, 39);
+            writeTypeScriptCheckResponse(bc, x.val);
+            break;
+        }
+        case "ExecutionDescriptorResponse": {
+            bare.writeU8(bc, 40);
+            writeExecutionDescriptorResponse(bc, x.val);
+            break;
+        }
+        case "ExecutionListResponse": {
+            bare.writeU8(bc, 41);
+            writeExecutionListResponse(bc, x.val);
+            break;
+        }
+        case "ExecutionDeletedResponse": {
+            bare.writeU8(bc, 42);
+            writeExecutionDeletedResponse(bc, x.val);
+            break;
+        }
+        case "ExecutionIoResponse": {
+            bare.writeU8(bc, 43);
+            writeExecutionIoResponse(bc, x.val);
+            break;
+        }
+        case "ExecutionOutputPageResponse": {
+            bare.writeU8(bc, 44);
+            writeExecutionOutputPageResponse(bc, x.val);
+            break;
+        }
     }
 }
 export function readResponseFrame(bc) {
@@ -2991,6 +4383,22 @@ export function writeProcessExitedEvent(bc, x) {
     bare.writeString(bc, x.processId);
     bare.writeI32(bc, x.exitCode);
 }
+export function readExecutionCompletedEvent(bc) {
+    return {
+        executionId: bare.readString(bc),
+        generation: bare.readU64(bc),
+        outcome: readExecutionOutcome(bc),
+        exitCode: read38(bc),
+        error: read46(bc),
+    };
+}
+export function writeExecutionCompletedEvent(bc, x) {
+    bare.writeString(bc, x.executionId);
+    bare.writeU64(bc, x.generation);
+    writeExecutionOutcome(bc, x.outcome);
+    write38(bc, x.exitCode);
+    write46(bc, x.error);
+}
 export function readStructuredEvent(bc) {
     return {
         name: bare.readString(bc),
@@ -3015,6 +4423,10 @@ export function readEventPayload(bc) {
             return { tag: "StructuredEvent", val: readStructuredEvent(bc) };
         case 4:
             return { tag: "ExtEnvelope", val: readExtEnvelope(bc) };
+        case 5:
+            return { tag: "ExecutionOutputEvent", val: readExecutionOutputEvent(bc) };
+        case 6:
+            return { tag: "ExecutionCompletedEvent", val: readExecutionCompletedEvent(bc) };
         default: {
             bc.offset = offset;
             throw new bare.BareError(offset, "invalid tag");
@@ -3048,6 +4460,16 @@ export function writeEventPayload(bc, x) {
             writeExtEnvelope(bc, x.val);
             break;
         }
+        case "ExecutionOutputEvent": {
+            bare.writeU8(bc, 5);
+            writeExecutionOutputEvent(bc, x.val);
+            break;
+        }
+        case "ExecutionCompletedEvent": {
+            bare.writeU8(bc, 6);
+            writeExecutionCompletedEvent(bc, x.val);
+            break;
+        }
     }
 }
 export function readEventFrame(bc) {
@@ -3139,37 +4561,28 @@ export function writeSidecarRequestFrame(bc, x) {
     writeOwnershipScope(bc, x.ownership);
     writeSidecarRequestPayload(bc, x.payload);
 }
-function read36(bc) {
-    return bare.readBool(bc) ? readJsonUtf8(bc) : null;
-}
-function write36(bc, x) {
-    bare.writeBool(bc, x != null);
-    if (x != null) {
-        writeJsonUtf8(bc, x);
-    }
-}
 export function readHostCallbackResultResponse(bc) {
     return {
         invocationId: bare.readString(bc),
-        result: read36(bc),
+        result: read33(bc),
         error: read0(bc),
     };
 }
 export function writeHostCallbackResultResponse(bc, x) {
     bare.writeString(bc, x.invocationId);
-    write36(bc, x.result);
+    write33(bc, x.result);
     write0(bc, x.error);
 }
 export function readJsBridgeResultResponse(bc) {
     return {
         callId: bare.readString(bc),
-        result: read36(bc),
+        result: read33(bc),
         error: read0(bc),
     };
 }
 export function writeJsBridgeResultResponse(bc, x) {
     bare.writeString(bc, x.callId);
-    write36(bc, x.result);
+    write33(bc, x.result);
     write0(bc, x.error);
 }
 export function readSidecarResponsePayload(bc) {
@@ -3221,6 +4634,45 @@ export function writeSidecarResponseFrame(bc, x) {
     writeOwnershipScope(bc, x.ownership);
     writeSidecarResponsePayload(bc, x.payload);
 }
+export function readShutdownControl(bc) {
+    return {
+        reason: bare.readString(bc),
+    };
+}
+export function writeShutdownControl(bc, x) {
+    bare.writeString(bc, x.reason);
+}
+export function readControlPayload(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return { tag: "ShutdownControl", val: readShutdownControl(bc) };
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeControlPayload(bc, x) {
+    switch (x.tag) {
+        case "ShutdownControl": {
+            bare.writeU8(bc, 0);
+            writeShutdownControl(bc, x.val);
+            break;
+        }
+    }
+}
+export function readControlFrame(bc) {
+    return {
+        schema: readProtocolSchema(bc),
+        payload: readControlPayload(bc),
+    };
+}
+export function writeControlFrame(bc, x) {
+    writeProtocolSchema(bc, x.schema);
+    writeControlPayload(bc, x.payload);
+}
 export function readProtocolFrame(bc) {
     const offset = bc.offset;
     const tag = bare.readU8(bc);
@@ -3235,6 +4687,8 @@ export function readProtocolFrame(bc) {
             return { tag: "SidecarRequestFrame", val: readSidecarRequestFrame(bc) };
         case 4:
             return { tag: "SidecarResponseFrame", val: readSidecarResponseFrame(bc) };
+        case 5:
+            return { tag: "ControlFrame", val: readControlFrame(bc) };
         default: {
             bc.offset = offset;
             throw new bare.BareError(offset, "invalid tag");
@@ -3268,6 +4722,11 @@ export function writeProtocolFrame(bc, x) {
             writeSidecarResponseFrame(bc, x.val);
             break;
         }
+        case "ControlFrame": {
+            bare.writeU8(bc, 5);
+            writeControlFrame(bc, x.val);
+            break;
+        }
     }
 }
 export function encodeProtocolFrame(x, config) {