@opengeni/runtime 2.5.3-canary.0 → 2.5.3-canary.2

package/dist/{chunk-VVEGJPDR.js → chunk-46BFUGFL.js}

@@ -15993,6 +15993,9 @@ function agentErrorToControlError(err, controlRequestId = null) {
   }
 }
 function payloadTooLargeMessage(detail) {
+  if (detail.direction === "request") {
+    return "The request exceeds the machine link's per-message size limit and was not sent. The machine is not offline. Use a supported bounded transfer for large file content.";
+  }
   const encoded = detail.encoded_bytes;
   const max = detail.max_payload;
   const sizes = encoded && max ? `The result was ${encoded} bytes, over the machine link's ${max}-byte per-message limit. ` : "The result was larger than the machine link can deliver in a single message. ";
@@ -16105,6 +16108,18 @@ var NatsControlRpc = class {
     } catch (err) {
       const denied = natsAuthorizationFailure(err);
       if (denied) throw denied;
+      if (typeof err === "object" && err !== null && "code" in err && err.code === "MAX_PAYLOAD_EXCEEDED") {
+        return {
+          requestId: req.requestId,
+          error: {
+            code: ErrorCode.ERROR_CODE_PAYLOAD_TOO_LARGE,
+            message: "outbound control request exceeds the transport payload limit",
+            retryable: false,
+            detail: { direction: "request", encoded_bytes: String(payload.byteLength) }
+          },
+          result: void 0
+        };
+      }
       if (isNoRespondersError(err)) {
         return offlineControlResponse(req.requestId, true);
       }
@@ -16185,6 +16200,15 @@ function assemble(error, f) {
 function renderSelfhostedFault(error) {
   const detail = error.detail;
   if (error.payloadTooLarge || error.code === ErrorCode2.ERROR_CODE_PAYLOAD_TOO_LARGE) {
+    if (detail.direction === "request") {
+      return assemble(error, {
+        headline: "the request was too large to send",
+        happened: "the request was not sent because it exceeded the per-message size limit",
+        layer: "the machine link's outbound request size limit, not machine availability",
+        preserved: "the rejected request did not execute on the machine",
+        tryNext: "use a supported bounded transfer; retrying the unchanged request will not help"
+      });
+    }
     if (detail.failure_code === "OP_OVERFLOW") {
       const retained = detail.retained_bytes ? `after retaining ${detail.retained_bytes} bytes of output` : "when its output exceeded what the machine can retain for delivery";
       return assemble(error, {
@@ -25876,6 +25900,120 @@ import {
 } from "@opengeni/agent-proto";
 import { DESKTOP_STREAM_PORT as DESKTOP_STREAM_PORT4 } from "@opengeni/contracts";
 
+// src/sandbox/selfhosted/file-transfer.ts
+import { blake3 } from "@noble/hashes/blake3";
+import { bytesToHex } from "@noble/hashes/utils";
+import { OpState } from "@opengeni/agent-proto";
+var SELFHOSTED_FILE_CHUNK_BYTES = 256 * 1024;
+function fileContentDigest(content) {
+  return bytesToHex(blake3(content));
+}
+var FileTransferOutcomeError = class extends Error {
+  constructor(operationId, phase, cause, observationError) {
+    const detail = cause instanceof Error ? cause.message : "unknown failure";
+    const observation = observationError instanceof Error ? ` Outcome check: ${observationError.message}` : "";
+    super(
+      `File transfer ${operationId} ${phase} failed: ${detail}.${observation} No mutation was replayed; inspect the destination before another edit.`,
+      { cause }
+    );
+    this.operationId = operationId;
+    this.phase = phase;
+    this.observationError = observationError;
+    this.name = "FileTransferOutcomeError";
+  }
+  retryable = false;
+};
+async function transferEditorFile(input) {
+  const opId = `fsw-${crypto.randomUUID()}`;
+  const digest = fileContentDigest(input.content);
+  const checked = (reply) => {
+    if (reply.error) throw agentErrorToControlError(reply.error, reply.requestId);
+    if (!reply.result) throw new Error("The machine omitted the file-transfer result.");
+    return reply.result;
+  };
+  const send = async (requestId2, op) => {
+    const reply = await input.request(requestId2, op);
+    if (reply.requestId !== requestId2)
+      throw new Error("The machine returned a mismatched file-transfer response identity.");
+    return checked(reply);
+  };
+  const isVerified = (observed) => !(observed.$case !== "opStatus" || observed.opStatus.opId !== opId || observed.opStatus.state !== OpState.OP_STATE_COMPLETE || observed.opStatus.exit?.exitCode !== 0 || observed.opStatus.exit.cancelled || observed.opStatus.exit.timedOut || observed.opStatus.exit.failureCode || observed.opStatus.exit.digests.content !== digest || observed.opStatus.exit.totals.content !== String(input.content.byteLength));
+  const verifyOutcome = async (cancelRunning = false) => {
+    const observed = await send(crypto.randomUUID(), { $case: "opQuery", opQuery: { opId } });
+    if (isVerified(observed)) return;
+    if (cancelRunning && observed.$case === "opStatus" && observed.opStatus.opId === opId && observed.opStatus.state === OpState.OP_STATE_RUNNING) {
+      const cancelled = await send(crypto.randomUUID(), { $case: "opCancel", opCancel: { opId } });
+      if (isVerified(cancelled)) return;
+      if (cancelled.$case === "opStatus" && cancelled.opStatus.opId === opId && cancelled.opStatus.state === OpState.OP_STATE_COMPLETE && cancelled.opStatus.exit?.cancelled) {
+        throw new Error("Cancellation of the abandoned transfer's private staging was verified.");
+      }
+    }
+    throw new Error(
+      "The file-transfer outcome is not verified; the operation was not replayed. Inspect the destination before another edit."
+    );
+  };
+  let phase = "begin";
+  try {
+    const begun = await send(opId, {
+      $case: "opStart",
+      opStart: {
+        op: {
+          $case: "fsWrite",
+          fsWrite: {
+            path: input.path,
+            createParents: true,
+            mode: 0,
+            expectedBaseDigest: input.baseContent === void 0 ? "" : fileContentDigest(input.baseContent),
+            expectedAbsent: input.baseContent === void 0,
+            contentDigest: digest,
+            contentSize: String(input.content.byteLength)
+          }
+        },
+        windowBytes: "0",
+        deadlineMs: "0",
+        originId: ""
+      }
+    });
+    if (begun.$case !== "opStart" || !begun.opStart.accepted || begun.opStart.status?.opId !== opId) {
+      throw new Error("The machine did not accept the exact file-transfer operation.");
+    }
+    phase = "upload";
+    let offset = 0;
+    let seq = 0;
+    do {
+      const end = Math.min(input.content.byteLength, offset + SELFHOSTED_FILE_CHUNK_BYTES);
+      const reply = await send(crypto.randomUUID(), {
+        $case: "writeChunk",
+        writeChunk: {
+          opId,
+          seq: String(seq),
+          offset: String(offset),
+          bytes: input.content.subarray(offset, end),
+          last: end === input.content.byteLength
+        }
+      });
+      if (reply.$case !== "writeChunk" || reply.writeChunk.seq !== String(seq)) {
+        throw new Error(
+          "The machine returned a mismatched file-transfer acknowledgment; no chunk was replayed."
+        );
+      }
+      offset = end;
+      seq += 1;
+    } while (offset < input.content.byteLength);
+    phase = "verify";
+    await verifyOutcome();
+  } catch (error) {
+    if (phase === "verify") throw new FileTransferOutcomeError(opId, phase, error);
+    try {
+      await verifyOutcome(true);
+      return { recovered: true };
+    } catch (observationError) {
+      throw new FileTransferOutcomeError(opId, phase, error, observationError);
+    }
+  }
+  return { recovered: false };
+}
+
 // src/sandbox/selfhosted/retry-policy.ts
 var SELFHOSTED_IDEMPOTENT_READONLY_OPS = /* @__PURE__ */ new Set([
   "ping",
@@ -25929,15 +26067,15 @@ var defaultSelfhostedRetryClock = {
 };
 
 // src/sandbox/selfhosted/op-stream.ts
-import { blake3 } from "@noble/hashes/blake3";
-import { bytesToHex } from "@noble/hashes/utils";
+import { blake3 as blake32 } from "@noble/hashes/blake3";
+import { bytesToHex as bytesToHex2 } from "@noble/hashes/utils";
 import {
   ErrorCode as ErrorCode3,
   OpAck,
   OpChannel,
   OpFrame,
   OpLostReason,
-  OpState
+  OpState as OpState2
 } from "@opengeni/agent-proto";
 
 // src/sandbox/selfhosted/op-transport.ts
@@ -26260,7 +26398,7 @@ var OpConsumer = class {
   };
   outputFrames = [];
   outputDecoders = { stdout: new TextDecoder(), stderr: new TextDecoder() };
-  hashes = { stdout: blake3.create(), stderr: blake3.create() };
+  hashes = { stdout: blake32.create(), stderr: blake32.create() };
   totals = { stdout: 0n, stderr: 0n };
   captureOnly = false;
   receivedPayloadBytes = 0n;
@@ -26429,7 +26567,7 @@ var OpConsumer = class {
         if (result.$case !== "opStatus") {
           throw protocolError(`op-stream cancel: unexpected result ${result.$case}`);
         }
-        if (result.opStatus.state === OpState.OP_STATE_LOST) {
+        if (result.opStatus.state === OpState2.OP_STATE_LOST) {
           throw lostToControlError(result.opStatus);
         }
         await this.attach(0);
@@ -26498,7 +26636,7 @@ var OpConsumer = class {
         if (!result.opStart.accepted) {
           throw this.refusedStart(status);
         }
-        if (status?.state === OpState.OP_STATE_LOST) {
+        if (status?.state === OpState2.OP_STATE_LOST) {
           throw lostToControlError(status);
         }
         return drainingRetries + blipRetries;
@@ -26541,7 +26679,7 @@ var OpConsumer = class {
         detail: { cancelled: "true" }
       });
     }
-    if (status?.state === OpState.OP_STATE_LOST) {
+    if (status?.state === OpState2.OP_STATE_LOST) {
       return lostToControlError(status);
     }
     return protocolError("op-stream start: the runner refused the op without a typed reason");
@@ -26589,7 +26727,7 @@ var OpConsumer = class {
     if (result.$case !== "opStatus") {
       throw protocolError(`op-stream attach: unexpected result ${result.$case}`);
     }
-    if (result.opStatus.state === OpState.OP_STATE_LOST) {
+    if (result.opStatus.state === OpState2.OP_STATE_LOST) {
       throw lostToControlError(result.opStatus);
     }
     return result.opStatus;
@@ -26779,7 +26917,7 @@ var OpConsumer = class {
         throw protocolError(`op-stream query: unexpected result ${result.$case}`);
       }
       const status = result.opStatus;
-      if (status.state === OpState.OP_STATE_LOST) {
+      if (status.state === OpState2.OP_STATE_LOST) {
         reject(lostToControlError(status));
         return;
       }
@@ -26819,8 +26957,8 @@ var OpConsumer = class {
       }
       const declaredDigest = exit.digests[channel];
       if (declaredDigest) {
-        const digest = bytesToHex(
-          this.captureOnly ? this.hashes[channel].clone().digest() : blake3(bytes)
+        const digest = bytesToHex2(
+          this.captureOnly ? this.hashes[channel].clone().digest() : blake32(bytes)
         );
         if (digest !== declaredDigest) {
           throw protocolError(
@@ -27000,6 +27138,7 @@ var SelfhostedSession = class {
   resourcePolicy;
   resourcePolicySupported;
   operationCpuQuotaSupported;
+  transactionalFsWriteSupported;
   defaultOpStream;
   connectionInstanceId;
   resolveOperationAdmission;
@@ -27059,6 +27198,7 @@ var SelfhostedSession = class {
     this.resourcePolicy = normalizeOperationResourcePolicy(deps.operationResourcePolicy);
     this.resourcePolicySupported = deps.operationResourcePolicySupported === true;
     this.operationCpuQuotaSupported = deps.operationCpuQuotaSupported === true;
+    this.transactionalFsWriteSupported = deps.transactionalFsWriteSupported === true;
     this.defaultOpStream = deps.opStream;
     this.connectionInstanceId = deps.connectionInstanceId;
     this.resolveOperationAdmission = deps.resolveOperationAdmission;
@@ -27070,7 +27210,8 @@ var SelfhostedSession = class {
       connectionInstanceId: deps.connectionInstanceId,
       subject: this.subject,
       resourcePolicy: this.resourcePolicy,
-      opStream: deps.opStream
+      opStream: deps.opStream,
+      transactionalFsWriteSupported: this.transactionalFsWriteSupported
     }) : void 0;
     this.state = {
       agentId: deps.agentId,
@@ -27130,7 +27271,8 @@ var SelfhostedSession = class {
         connectionInstanceId: this.connectionInstanceId,
         subject: this.subject,
         resourcePolicy: commandPolicy ? this.resourcePolicy : void 0,
-        opStream: this.defaultOpStream
+        opStream: this.defaultOpStream,
+        transactionalFsWriteSupported: this.transactionalFsWriteSupported
       };
     }
     const resolved = await this.resolveOperationAdmission();
@@ -27163,7 +27305,8 @@ var SelfhostedSession = class {
         resolved.connectionInstanceId
       ),
       resourcePolicy: commandPolicy ? resourcePolicy : void 0,
-      opStream: resolved.opStream
+      opStream: resolved.opStream,
+      transactionalFsWriteSupported: resolved.transactionalFsWriteSupported === true
     };
   }
   async admitCommand() {
@@ -27306,7 +27449,7 @@ var SelfhostedSession = class {
           machineId: this.agentId,
           faultClass: selfhostedFaultClass(error),
           // Known only on a PAYLOAD_TOO_LARGE fault (the agent's encoded_bytes detail).
-          ...Number.isFinite(encoded) ? { replyBytes: encoded } : {}
+          ...Number.isFinite(encoded) && error.detail.direction !== "request" ? { replyBytes: encoded } : {}
         });
         if (error.draining && drainingRetries > 0) {
           throw drainingExhaustedError(error, drainingRetries);
@@ -27671,8 +27814,145 @@ var SelfhostedSession = class {
     }
     const pathExists3 = (path) => this.pathExists(path, runAs);
     const readText2 = async (path) => decoder.decode(await this.readFile({ path, ...runAs ? { runAs } : {} }));
-    const writeText = async (path, content) => {
-      await this.writeFile({ path, content, createParents: true });
+    const writeText = async (path, content, base) => {
+      const bytes = encoder.encode(content);
+      if (bytes.byteLength <= SELFHOSTED_FILE_CHUNK_BYTES) {
+        await this.writeFile({ path, content, createParents: true });
+        return;
+      }
+      const initial = await this.admitOperation(false);
+      if (!initial.transactionalFsWriteSupported) {
+        await this.writeFile({ path, content, createParents: true });
+        return;
+      }
+      if (runAs) {
+        throw new SelfhostedControlError({
+          code: ErrorCode4.ERROR_CODE_UNSUPPORTED,
+          message: "Transactional file editing does not support runAs impersonation; no file was written.",
+          reason: null,
+          retryable: false
+        });
+      }
+      const requestTransfer = async (requestId2, op) => {
+        const startedAt = Date.now();
+        try {
+          const current = await this.admitOperation(false);
+          if (!current.transactionalFsWriteSupported || current.subject !== initial.subject || current.connectionInstanceId !== initial.connectionInstanceId) {
+            throw new Error(
+              "The authorized machine connection changed during the file transfer; the operation was not replayed."
+            );
+          }
+          const response = await this.controlRpc.request(
+            current.subject,
+            {
+              requestId: requestId2,
+              epoch: this.epoch,
+              op,
+              resourcePolicy: void 0
+            },
+            { timeoutMs: this.timeoutMs }
+          );
+          if (response.requestId !== requestId2)
+            throw new Error("The machine returned a mismatched file-transfer response identity.");
+          const error = response.error ? agentErrorToControlError(response.error, requestId2) : void 0;
+          this.emitOp({
+            op: op.$case,
+            outcome: error || !response.result ? "failed" : "ok",
+            healed: false,
+            retries: 0,
+            durationMs: Date.now() - startedAt,
+            machineId: this.agentId,
+            ...error ? { code: error.code, reason: error.reason, faultClass: selfhostedFaultClass(error) } : {}
+          });
+          return response;
+        } catch (error) {
+          this.emitOp({
+            op: op.$case,
+            outcome: "failed",
+            healed: false,
+            retries: 0,
+            durationMs: Date.now() - startedAt,
+            machineId: this.agentId,
+            ...error instanceof SelfhostedControlError ? { code: error.code, reason: error.reason, faultClass: selfhostedFaultClass(error) } : {}
+          });
+          throw error;
+        }
+      };
+      const resolvedBase = typeof base === "function" ? await base() : base;
+      const transferStartedAt = Date.now();
+      try {
+        const result = await transferEditorFile({
+          path: resolveConnectedMachinePath(this.workspaceRoot, path),
+          content: bytes,
+          ...resolvedBase === void 0 ? {} : { baseContent: encoder.encode(resolvedBase) },
+          request: requestTransfer
+        });
+        this.emitOp({
+          op: "fsWrite",
+          outcome: "ok",
+          healed: result.recovered,
+          retries: 0,
+          durationMs: Date.now() - transferStartedAt,
+          machineId: this.agentId
+        });
+      } catch (error) {
+        this.emitOp({
+          op: "fsWrite",
+          outcome: "failed",
+          healed: false,
+          retries: 0,
+          durationMs: Date.now() - transferStartedAt,
+          machineId: this.agentId
+        });
+        throw error;
+      }
+      return async (source, sourceBase) => {
+        try {
+          const sourcePath = resolveConnectedMachinePath(this.workspaceRoot, source);
+          const sourceBytes = [];
+          let offset = 0;
+          let total = Infinity;
+          while (offset < total) {
+            const reply2 = await requestTransfer(crypto.randomUUID(), {
+              $case: "fsRead",
+              fsRead: {
+                path: sourcePath,
+                offset: String(offset),
+                length: String(SELFHOSTED_FILE_CHUNK_BYTES)
+              }
+            });
+            if (reply2.error) throw agentErrorToControlError(reply2.error);
+            if (reply2.result?.$case !== "fsRead")
+              throw new Error("Source verification response missing");
+            const part = reply2.result.fsRead;
+            total = safeWireSize(part.totalSize, "source file size");
+            if (!part.content.length && offset < total)
+              throw new Error("Source verification was incomplete");
+            sourceBytes.push(part.content);
+            offset += part.content.length;
+          }
+          const actual = new Uint8Array(offset);
+          let cursor = 0;
+          for (const chunk of sourceBytes) {
+            actual.set(chunk, cursor);
+            cursor += chunk.length;
+          }
+          if (fileContentDigest(actual) !== fileContentDigest(encoder.encode(sourceBase)))
+            throw new Error("Source changed before move cleanup");
+          const reply = await requestTransfer(crypto.randomUUID(), {
+            $case: "fsRemove",
+            fsRemove: { path: sourcePath, recursive: false }
+          });
+          if (reply.error) throw agentErrorToControlError(reply.error);
+          if (reply.result?.$case !== "fsRemove")
+            throw new Error("Source cleanup response missing");
+        } catch (cause) {
+          throw new Error(
+            "The destination edit was verified, but source cleanup was not verified. The move was not replayed; inspect both paths.",
+            { cause }
+          );
+        }
+      };
     };
     const deletePath = async (path) => {
       const result = await this.call({
@@ -27698,9 +27978,11 @@ var SelfhostedSession = class {
         const current = await readText2(operation.path);
         const next = applyDiff2(current, operation.diff);
         const destination = operation.moveTo ?? operation.path;
-        await writeText(destination, next);
+        const destinationBase = destination === operation.path ? current : async () => await pathExists3(destination) ? await readText2(destination) : void 0;
+        const cleanup = await writeText(destination, next, destinationBase);
         if (operation.moveTo && destination !== operation.path) {
-          await deletePath(operation.path);
+          if (cleanup) await cleanup(operation.path, current);
+          else await deletePath(operation.path);
         }
         return {};
       },
@@ -27984,6 +28266,7 @@ var SelfhostedSandboxClient = class {
   operationResourcePolicy;
   operationResourcePolicySupported;
   operationCpuQuotaSupported;
+  transactionalFsWriteSupported;
   resolveOperationAdmission;
   adoptBackgroundCommand;
   settleBackgroundCommand;
@@ -28006,6 +28289,7 @@ var SelfhostedSandboxClient = class {
     this.operationResourcePolicy = opts.operationResourcePolicy;
     this.operationResourcePolicySupported = opts.operationResourcePolicySupported;
     this.operationCpuQuotaSupported = opts.operationCpuQuotaSupported;
+    this.transactionalFsWriteSupported = opts.transactionalFsWriteSupported;
     this.resolveOperationAdmission = opts.resolveOperationAdmission;
     this.adoptBackgroundCommand = opts.adoptBackgroundCommand;
     this.settleBackgroundCommand = opts.settleBackgroundCommand;
@@ -28039,6 +28323,7 @@ var SelfhostedSandboxClient = class {
         operationResourcePolicySupported: this.operationResourcePolicySupported
       } : {},
       ...this.operationCpuQuotaSupported !== void 0 ? { operationCpuQuotaSupported: this.operationCpuQuotaSupported } : {},
+      transactionalFsWriteSupported: this.transactionalFsWriteSupported === true,
       ...this.resolveOperationAdmission !== void 0 ? { resolveOperationAdmission: this.resolveOperationAdmission } : {},
       ...this.adoptBackgroundCommand !== void 0 ? { adoptBackgroundCommand: this.adoptBackgroundCommand } : {},
       ...this.settleBackgroundCommand !== void 0 ? { settleBackgroundCommand: this.settleBackgroundCommand } : {},
@@ -28109,6 +28394,7 @@ async function buildSelfhostedBackendSession(deps) {
       operationResourcePolicySupported: deps.operationResourcePolicySupported
     } : {},
     ...deps.operationCpuQuotaSupported !== void 0 ? { operationCpuQuotaSupported: deps.operationCpuQuotaSupported } : {},
+    transactionalFsWriteSupported: deps.transactionalFsWriteSupported === true,
     ...deps.resolveOperationAdmission !== void 0 ? { resolveOperationAdmission: deps.resolveOperationAdmission } : {},
     ...deps.adoptBackgroundCommand !== void 0 ? { adoptBackgroundCommand: deps.adoptBackgroundCommand } : {},
     ...deps.settleBackgroundCommand !== void 0 ? { settleBackgroundCommand: deps.settleBackgroundCommand } : {},
@@ -35006,15 +35292,15 @@ function concat(a, b) {
 }
 
 // src/sandbox/selfhosted/op-testing.ts
-import { blake3 as blake32 } from "@noble/hashes/blake3";
-import { bytesToHex as bytesToHex2 } from "@noble/hashes/utils";
+import { blake3 as blake33 } from "@noble/hashes/blake3";
+import { bytesToHex as bytesToHex3 } from "@noble/hashes/utils";
 import {
   ErrorCode as ErrorCode6,
   OpAck as OpAck2,
   OpChannel as OpChannel2,
   OpFrame as OpFrame2,
   OpLostReason as OpLostReason2,
-  OpState as OpState2
+  OpState as OpState3
 } from "@opengeni/agent-proto";
 var InMemoryOpStreamTransport = class {
   available = true;
@@ -35307,8 +35593,9 @@ var FakeOpRunner = class {
     const complete = !run2.script.live || run2.liveEmitted;
     return {
       opId,
-      state: complete ? OpState2.OP_STATE_COMPLETE : OpState2.OP_STATE_RUNNING,
+      state: complete ? OpState3.OP_STATE_COMPLETE : OpState3.OP_STATE_RUNNING,
       nextSeq: complete ? (run2.exitSeq + 1n).toString() : "1",
+      writeOffset: "0",
       exit: complete ? run2.exit : void 0,
       lostReason: OpLostReason2.OP_LOST_REASON_UNSPECIFIED
     };
@@ -35342,7 +35629,7 @@ var FakeOpRunner = class {
     const totals = {};
     for (const channel of ["stdout", "stderr"]) {
       const joined = concat2(channelBytes[channel]);
-      digests[channel] = bytesToHex2(blake32(joined));
+      digests[channel] = bytesToHex3(blake33(joined));
       totals[channel] = String(joined.byteLength);
     }
     const exit = {
@@ -35448,7 +35735,8 @@ function statusOnly(requestId2, status) {
 function lostStatus(opId) {
   return {
     opId,
-    state: OpState2.OP_STATE_LOST,
+    state: OpState3.OP_STATE_LOST,
+    writeOffset: "0",
     nextSeq: "0",
     exit: void 0,
     lostReason: OpLostReason2.OP_LOST_REASON_EVICTED
@@ -35457,7 +35745,8 @@ function lostStatus(opId) {
 function cancelledStatus(opId) {
   return {
     opId,
-    state: OpState2.OP_STATE_COMPLETE,
+    state: OpState3.OP_STATE_COMPLETE,
+    writeOffset: "0",
     nextSeq: "1",
     exit: {
       exitCode: -1,
@@ -35577,6 +35866,7 @@ function makeActiveBackendResolver(deps) {
         operationResourcePolicy: connection.operationResourcePolicy,
         operationResourcePolicySupported: connection.operationResourcePolicySupported,
         operationCpuQuotaSupported: connection.operationCpuQuotaSupported,
+        transactionalFsWriteSupported: connection.transactionalFsWriteSupported === true,
         // The routing proxy caches this session by sandbox+epoch, but command
         // policy and runner authority are mutable. Re-read one coherent DB
         // snapshot only when a new exec/Git is admitted.
@@ -37003,4 +37293,4 @@ export {
   collectSandboxEnvironment2 as collectSandboxEnvironment,
   parseExposedPorts2 as parseExposedPorts
 };
-//# sourceMappingURL=chunk-VVEGJPDR.js.map
+//# sourceMappingURL=chunk-46BFUGFL.js.map