@opendatalabs/vana-sdk 3.23.0 → 4.0.0

package/dist/index.node.cjs

@@ -20,6 +20,7 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
   // If the importer is in node compatibility mode or this is not an ESM
   // file that has been converted to a CommonJS file using a Babel-
@@ -1178,14 +1179,11 @@ __export(index_node_exports, {
   AccountPersonalServerLiteOwnerBindingError: () => AccountPersonalServerLiteOwnerBindingError,
   AccountPersonalServerRegistrationError: () => AccountPersonalServerRegistrationError,
   BUILDER_REGISTRATION_TYPES: () => BUILDER_REGISTRATION_TYPES,
-  BlockchainError: () => BlockchainError,
   BrowserPlatformAdapter: () => BrowserPlatformAdapter,
-  BuilderUnknownError: () => BuilderUnknownError,
   CLAIM_POLL_FLOOR_MS: () => CLAIM_POLL_FLOOR_MS,
   CONTRACTS: () => CONTRACTS,
   CallbackStorage: () => CallbackStorage,
   ContractFactory: () => ContractFactory,
-  ContractNotFoundError: () => ContractNotFoundError,
   DATA_ACCESS_OP_TYPE: () => DATA_ACCESS_OP_TYPE,
   DATA_REGISTRY_STATUS_ABI: () => DATA_REGISTRY_STATUS_ABI,
   DEFAULT_DERIVATIVE_STATUS_POLL_INTERVAL_MS: () => DEFAULT_DERIVATIVE_STATUS_POLL_INTERVAL_MS,
@@ -1198,21 +1196,9 @@ __export(index_node_exports, {
   DERIVATIVE_QUESTIONS_PATH: () => DERIVATIVE_QUESTIONS_PATH,
   DERIVATIVE_STATUS_PATH: () => DERIVATIVE_STATUS_PATH,
   DataFileEnvelopeSchema: () => DataFileEnvelopeSchema,
-  DataPointDeletedError: () => DataPointDeletedError,
-  DataPointNotFoundError: () => DataPointNotFoundError,
   DataPointStatus: () => DataPointStatus,
-  DataPointVersionConflictError: () => DataPointVersionConflictError,
-  DerivativeComputeUnavailableError: () => DerivativeComputeUnavailableError,
-  DerivativeCycleError: () => DerivativeCycleError,
-  DerivativeDerivedScopeRequiredError: () => DerivativeDerivedScopeRequiredError,
   DerivativeErrorCodeSchema: () => DerivativeErrorCodeSchema,
-  DerivativeQuestionFailedError: () => DerivativeQuestionFailedError,
-  DerivativeQuestionInvalidError: () => DerivativeQuestionInvalidError,
-  DerivativeQuestionNotFoundError: () => DerivativeQuestionNotFoundError,
-  DerivativeQuestionRejectedError: () => DerivativeQuestionRejectedError,
   DerivativeQuestionSchema: () => DerivativeQuestionSchema,
-  DerivativeQuestionTimeoutError: () => DerivativeQuestionTimeoutError,
-  DerivativeSourceNotGrantedError: () => DerivativeSourceNotGrantedError,
   DerivativeStatusSchema: () => DerivativeStatusSchema,
   DropboxStorage: () => DropboxStorage,
   ECIESError: () => ECIESError,
@@ -1220,42 +1206,35 @@ __export(index_node_exports, {
   ENCLAVE_TRUST_ANCHORS: () => ENCLAVE_TRUST_ANCHORS,
   ENCLAVE_WALLET_PURPOSE: () => ENCLAVE_WALLET_PURPOSE,
   ESCROW_DEPOSIT_ABI: () => ESCROW_DEPOSIT_ABI2,
-  ExpiredTokenError: () => ExpiredTokenError,
+  EscrowWithdrawalLifecycleError: () => EscrowWithdrawalLifecycleError,
+  EscrowWithdrawalRejectionError: () => EscrowWithdrawalRejectionError,
+  ExpiredTokenError: () => import_errors14.ExpiredTokenError,
   FEE_REGISTRY_ABI: () => FEE_REGISTRY_ABI,
   GENERIC_PAYMENT_TYPES: () => GENERIC_PAYMENT_TYPES,
   GRANT_OP_TYPE: () => GRANT_OP_TYPE,
   GRANT_REGISTRATION_TYPES: () => GRANT_REGISTRATION_TYPES,
   GRANT_REVOCATION_TYPES: () => GRANT_REVOCATION_TYPES,
   GoogleDriveStorage: () => GoogleDriveStorage,
-  GrantInvalidError: () => GrantInvalidError,
   InMemoryTokenStore: () => InMemoryTokenStore,
   IngestResponseSchema: () => IngestResponseSchema,
-  InvalidConfigurationError: () => InvalidConfigurationError,
   InvalidScopeEntryError: () => InvalidScopeEntryError,
-  InvalidSignatureError: () => InvalidSignatureError,
+  InvalidSignatureError: () => import_errors14.InvalidSignatureError,
   IpfsStorage: () => IpfsStorage,
   JOB_OPERATIONS: () => JOB_OPERATIONS,
   JOB_PROTOCOL_VERSION: () => JOB_PROTOCOL_VERSION,
+  JOB_RESULT_CHUNK_BYTES: () => JOB_RESULT_CHUNK_BYTES,
+  JOB_RESULT_FORMAT_VERSION: () => JOB_RESULT_FORMAT_VERSION,
   JOB_STATES: () => JOB_STATES,
   JobEnvelopeError: () => JobEnvelopeError,
-  JobIdTakenError: () => JobIdTakenError,
-  JobNotFoundError: () => JobNotFoundError,
-  JobRejectedError: () => JobRejectedError,
-  JobRequestTooLargeError: () => JobRequestTooLargeError,
-  JobTimeoutError: () => JobTimeoutError,
-  JobTransportError: () => JobTransportError,
-  JobsClientError: () => JobsClientError,
   LINEAGE_FIELD: () => LINEAGE_FIELD,
   LINEAGE_KEY: () => LINEAGE_KEY,
   LineageEntrySchema: () => LineageEntrySchema,
   LineageGraphSchema: () => LineageGraphSchema,
   LineageNodeSchema: () => LineageNodeSchema,
-  LineageReadError: () => LineageReadError,
   MASTER_KEY_MESSAGE: () => MASTER_KEY_MESSAGE,
   MASTER_SIGNATURE_DELIVERY_MAX_AGE_SECONDS: () => MASTER_SIGNATURE_DELIVERY_MAX_AGE_SECONDS,
   MASTER_SIGNATURE_DELIVERY_VERSION: () => MASTER_SIGNATURE_DELIVERY_VERSION,
   MAX_ATTEMPTS: () => MAX_ATTEMPTS,
-  MAX_INLINE_RESULT_BYTES: () => MAX_INLINE_RESULT_BYTES,
   MAX_JOB_DEADLINE_SECONDS: () => MAX_JOB_DEADLINE_SECONDS,
   MAX_LEASE_SECONDS: () => MAX_LEASE_SECONDS,
   MAX_LINEAGE_SOURCES: () => MAX_LINEAGE_SOURCES,
@@ -1263,15 +1242,12 @@ __export(index_node_exports, {
   MAX_QUESTION_MODEL_CHARS: () => MAX_QUESTION_MODEL_CHARS,
   MAX_QUESTION_SOURCE_SCOPES: () => MAX_QUESTION_SOURCE_SCOPES,
   MAX_WAIT_SECONDS: () => MAX_WAIT_SECONDS,
-  MissingAuthError: () => MissingAuthError,
+  MissingAuthError: () => import_errors14.MissingAuthError,
   NATIVE_ASSET_ADDRESS: () => NATIVE_ASSET_ADDRESS,
   NATIVE_VANA_ASSET: () => NATIVE_VANA_ASSET,
-  NetworkError: () => NetworkError,
   NodeECIESProvider: () => NodeECIESUint8Provider,
   NodePlatformAdapter: () => NodePlatformAdapter,
-  NonceError: () => NonceError,
   OAuthClient: () => OAuthClient,
-  OwnerNotReadyError: () => OwnerNotReadyError,
   PERSONAL_SERVER_LITE_OWNER_BINDING_PREFIX: () => PERSONAL_SERVER_LITE_OWNER_BINDING_PREFIX,
   PERSONAL_SERVER_LITE_OWNER_BINDING_PURPOSE: () => PERSONAL_SERVER_LITE_OWNER_BINDING_PURPOSE,
   PERSONAL_SERVER_LITE_OWNER_BINDING_VERSION: () => PERSONAL_SERVER_LITE_OWNER_BINDING_VERSION,
@@ -1280,9 +1256,6 @@ __export(index_node_exports, {
   PKCE_CHALLENGE_PATTERN: () => PKCE_CHALLENGE_PATTERN,
   PKCE_VERIFIER_PATTERN: () => PKCE_VERIFIER_PATTERN,
   PSError: () => PSError,
-  PermissionError: () => PermissionError,
-  PersonalServerError: () => PersonalServerError,
-  PersonalServerWriteError: () => PersonalServerWriteError,
   PinataStorage: () => PinataStorage,
   QUESTION_STATUSES: () => QUESTION_STATUSES,
   QuestionDeleteResultSchema: () => QuestionDeleteResultSchema,
@@ -1293,42 +1266,26 @@ __export(index_node_exports, {
   RECORD_DATA_ACCESS_TYPES: () => RECORD_DATA_ACCESS_TYPES,
   REGISTRATION_KIND_FOR_OP: () => REGISTRATION_KIND_FOR_OP,
   RESERVED_WRITE_KEYS: () => RESERVED_WRITE_KEYS,
-  ReadOnlyError: () => ReadOnlyError,
   RedactedLineageNodeSchema: () => RedactedLineageNodeSchema,
-  RelayerError: () => RelayerError,
   SCOPE_ACTIONS: () => SCOPE_ACTIONS,
   SEALED_ENVELOPE_VERSION: () => SEALED_ENVELOPE_VERSION,
   SERVER_REGISTRATION_TYPES: () => SERVER_REGISTRATION_TYPES,
   ScopeSchema: () => ScopeSchema,
-  SerializationError: () => SerializationError,
-  ServerUrlMismatchError: () => ServerUrlMismatchError,
-  SignatureError: () => SignatureError,
   StorageError: () => StorageError,
   StorageManager: () => StorageManager,
   TOMBSTONE_DATA_HASH: () => TOMBSTONE_DATA_HASH,
   TOMBSTONE_DATA_HASH_PREIMAGE: () => TOMBSTONE_DATA_HASH_PREIMAGE,
   TOMBSTONE_METADATA_HASH: () => TOMBSTONE_METADATA_HASH,
   TOMBSTONE_METADATA_HASH_PREIMAGE: () => TOMBSTONE_METADATA_HASH_PREIMAGE,
-  TransactionPendingError: () => TransactionPendingError,
   USER_PS_ID_DOMAIN: () => USER_PS_ID_DOMAIN,
-  UserRejectedRequestError: () => UserRejectedRequestError,
-  VanaError: () => VanaError,
   VanaStorage: () => VanaStorage,
+  WITHDRAW_AUTHORIZATION_TYPES: () => WITHDRAW_AUTHORIZATION_TYPES,
   WRITER_ATTRIBUTION_KEY: () => WRITER_ATTRIBUTION_KEY,
   WRITE_CONTENT_DISPOSITION_HEADER: () => WRITE_CONTENT_DISPOSITION_HEADER,
   WRITE_FILENAME_HEADER: () => WRITE_FILENAME_HEADER,
   WRITE_METADATA_HEADER: () => WRITE_METADATA_HEADER,
   WRITE_SESSION_PATH: () => WRITE_SESSION_PATH,
   WRITE_SIGNATURE_HEADER: () => WRITE_SIGNATURE_HEADER,
-  WriteConflictError: () => WriteConflictError,
-  WriteForbiddenError: () => WriteForbiddenError,
-  WriteLineageError: () => WriteLineageError,
-  WriteRejectedError: () => WriteRejectedError,
-  WriteRequestError: () => WriteRequestError,
-  WriteSessionError: () => WriteSessionError,
-  WriteSessionExpiredError: () => WriteSessionExpiredError,
-  WriteTransportError: () => WriteTransportError,
-  WriteUnauthorizedError: () => WriteUnauthorizedError,
   appRootPreimage: () => appRootPreimage,
   askPersonalServer: () => askPersonalServer,
   assertDerivedScopeNaming: () => assertDerivedScopeNaming,
@@ -1351,6 +1308,7 @@ __export(index_node_exports, {
   buildPersonalServerRegistrationTypedData: () => buildPersonalServerRegistrationTypedData,
   buildSetDataPointStatusRequest: () => buildSetDataPointStatusRequest,
   buildWeb3SignedHeader: () => buildWeb3SignedHeader,
+  buildWithdrawAuthorizationTypedData: () => buildWithdrawAuthorizationTypedData,
   builderRegistrationDomain: () => builderRegistrationDomain,
   canonicalJobRequestBytes: () => canonicalJobRequestBytes,
   chains: () => chains,
@@ -1433,6 +1391,7 @@ __export(index_node_exports, {
   normalizeBinaryMimeType: () => normalizeBinaryMimeType,
   openJobRequest: () => openJobRequest,
   openJobResult: () => openJobResult,
+  openJobResultStream: () => openJobResultStream,
   openWriteSession: () => openWriteSession,
   parsePSError: () => parsePSError,
   parsePersonalServerPaymentRequired: () => parsePersonalServerPaymentRequired,
@@ -1458,6 +1417,7 @@ __export(index_node_exports, {
   scopeToPathSegments: () => scopeToPathSegments,
   sealJobRequest: () => sealJobRequest,
   sealJobResult: () => sealJobResult,
+  sealJobResultStream: () => sealJobResultStream,
   serializeECIES: () => serializeECIES,
   serverRegistrationDomain: () => serverRegistrationDomain,
   sessionCoversScope: () => sessionCoversScope,
@@ -1476,351 +1436,12 @@ __export(index_node_exports, {
   verifyWeb3Signed: () => verifyWeb3Signed,
   waitForDerivativeStatus: () => waitForDerivativeStatus,
   waitForQuestion: () => waitForQuestion,
+  withdrawAuthorizationDomain: () => withdrawAuthorizationDomain,
   writeData: () => writeData,
   writePersonalServerData: () => writePersonalServerData
 });
 module.exports = __toCommonJS(index_node_exports);
-
-// src/errors.ts
-var VanaError = class extends Error {
-  constructor(message, code) {
-    super(message);
-    this.code = code;
-    this.name = this.constructor.name;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, this.constructor);
-    }
-  }
-  code;
-};
-var RelayerError = class extends VanaError {
-  constructor(message, statusCode, response) {
-    super(message, "RELAYER_ERROR");
-    this.statusCode = statusCode;
-    this.response = response;
-  }
-  statusCode;
-  response;
-};
-var UserRejectedRequestError = class extends VanaError {
-  constructor(message = "User rejected the signature request") {
-    super(message, "USER_REJECTED_REQUEST");
-  }
-};
-var InvalidConfigurationError = class extends VanaError {
-  constructor(message) {
-    super(message, "INVALID_CONFIGURATION");
-  }
-};
-var ContractNotFoundError = class extends VanaError {
-  constructor(contractName, chainId) {
-    super(
-      `Contract ${contractName} not found on chain ${chainId}`,
-      "CONTRACT_NOT_FOUND"
-    );
-  }
-};
-var BlockchainError = class extends VanaError {
-  constructor(message, originalError) {
-    super(message, "BLOCKCHAIN_ERROR");
-    this.originalError = originalError;
-  }
-  originalError;
-};
-var SerializationError = class extends VanaError {
-  constructor(message) {
-    super(message, "SERIALIZATION_ERROR");
-  }
-};
-var SignatureError = class extends VanaError {
-  constructor(message, originalError) {
-    super(message, "SIGNATURE_ERROR");
-    this.originalError = originalError;
-  }
-  originalError;
-};
-var NetworkError = class extends VanaError {
-  constructor(message, originalError) {
-    super(message, "NETWORK_ERROR");
-    this.originalError = originalError;
-  }
-  originalError;
-};
-var NonceError = class extends VanaError {
-  constructor(message) {
-    super(message, "NONCE_ERROR");
-  }
-};
-var PersonalServerError = class extends VanaError {
-  constructor(message, originalError) {
-    super(message, "PERSONAL_SERVER_ERROR");
-    this.originalError = originalError;
-  }
-  originalError;
-};
-var ServerUrlMismatchError = class extends VanaError {
-  constructor(existingUrl, providedUrl, serverId) {
-    super(
-      `Server ${serverId} is already registered with URL "${existingUrl}". Cannot change to "${providedUrl}".`,
-      "SERVER_URL_MISMATCH"
-    );
-    this.existingUrl = existingUrl;
-    this.providedUrl = providedUrl;
-    this.serverId = serverId;
-  }
-  existingUrl;
-  providedUrl;
-  serverId;
-};
-var PermissionError = class extends VanaError {
-  constructor(message, originalError) {
-    super(message, "PERMISSION_ERROR");
-    this.originalError = originalError;
-  }
-  originalError;
-};
-var ReadOnlyError = class extends VanaError {
-  constructor(operation, suggestion = "Initialize the SDK with a walletClient to perform this operation") {
-    super(
-      `Operation '${operation}' requires a wallet client. ${suggestion}`,
-      "READ_ONLY_ERROR"
-    );
-    this.operation = operation;
-    this.suggestion = suggestion;
-  }
-  /** The operation that was attempted */
-  operation;
-  /** Suggested solution for fixing the error */
-  suggestion;
-};
-var TransactionPendingError = class extends VanaError {
-  constructor(operationId, message, lastKnownStatus) {
-    super(
-      `Transaction operation pending: ${message} (operationId: ${operationId})`,
-      "TRANSACTION_PENDING"
-    );
-    this.operationId = operationId;
-    this.lastKnownStatus = lastKnownStatus;
-  }
-  operationId;
-  lastKnownStatus;
-  /**
-   * Converts the error to a JSON-serializable format.
-   *
-   * @remarks
-   * Useful for logging, storage, or transmission of error details.
-   *
-   * @returns JSON representation of the error
-   */
-  toJSON() {
-    return {
-      name: this.name,
-      code: this.code,
-      message: this.message,
-      operationId: this.operationId,
-      lastKnownStatus: this.lastKnownStatus
-    };
-  }
-};
-var PersonalServerWriteError = class extends VanaError {
-  constructor(message, code, status, errorCode = null, details) {
-    super(message, code);
-    this.status = status;
-    this.errorCode = errorCode;
-    this.details = details;
-  }
-  status;
-  errorCode;
-  details;
-};
-var WriteRequestError = class extends PersonalServerWriteError {
-  constructor(message, details) {
-    super(message, "WRITE_INVALID_REQUEST", void 0, null, details);
-  }
-};
-var WriteTransportError = class extends PersonalServerWriteError {
-  constructor(message, attempts, cause) {
-    super(message, "WRITE_TRANSPORT_ERROR", void 0, null, { attempts });
-    this.attempts = attempts;
-    this.cause = cause;
-  }
-  attempts;
-};
-var WriteSessionError = class extends PersonalServerWriteError {
-  constructor(message, status, errorCode = null, details) {
-    super(message, "WRITE_SESSION_REJECTED", status, errorCode, details);
-  }
-};
-var WriteSessionExpiredError = class extends PersonalServerWriteError {
-  constructor(message, details) {
-    super(message, "WRITE_SESSION_EXPIRED", void 0, null, details);
-  }
-};
-var WriteUnauthorizedError = class extends PersonalServerWriteError {
-  constructor(message, errorCode = null, details) {
-    super(message, "WRITE_UNAUTHORIZED", 401, errorCode, details);
-  }
-};
-var WriteForbiddenError = class extends PersonalServerWriteError {
-  constructor(message, errorCode = null, details) {
-    super(message, "WRITE_FORBIDDEN", 403, errorCode, details);
-  }
-};
-var WriteConflictError = class extends PersonalServerWriteError {
-  constructor(message, errorCode = null, details) {
-    super(message, "WRITE_CONFLICT", 409, errorCode, details);
-  }
-};
-var WriteLineageError = class extends PersonalServerWriteError {
-  constructor(message, status = 422, errorCode = null, details) {
-    super(message, "WRITE_LINEAGE_REJECTED", status, errorCode, details);
-  }
-};
-var WriteRejectedError = class extends PersonalServerWriteError {
-  constructor(message, status, errorCode = null, details) {
-    super(message, "WRITE_REJECTED", status, errorCode, details);
-  }
-};
-var JobsClientError = class extends VanaError {
-  constructor(message, code, status, errorCode = null, details) {
-    super(message, code);
-    this.status = status;
-    this.errorCode = errorCode;
-    this.details = details;
-  }
-  status;
-  errorCode;
-  details;
-};
-var BuilderUnknownError = class extends JobsClientError {
-  constructor(message, details) {
-    super(message, "JOB_BUILDER_UNKNOWN", 403, "BUILDER_UNKNOWN", details);
-  }
-};
-var GrantInvalidError = class extends JobsClientError {
-  constructor(message, details) {
-    super(message, "JOB_GRANT_INVALID", 403, "GRANT_INVALID", details);
-  }
-};
-var OwnerNotReadyError = class extends JobsClientError {
-  constructor(message, details) {
-    super(message, "JOB_OWNER_NOT_READY", 403, "OWNER_NOT_READY", details);
-  }
-};
-var JobIdTakenError = class extends JobsClientError {
-  constructor(message, details) {
-    super(message, "JOB_ID_TAKEN", 409, "JOB_ID_TAKEN", details);
-  }
-};
-var JobNotFoundError = class extends JobsClientError {
-  constructor(message, details) {
-    super(message, "JOB_NOT_FOUND", 404, "JOB_NOT_FOUND", details);
-  }
-};
-var JobRequestTooLargeError = class extends JobsClientError {
-  constructor(message, errorCode = "BODY_TOO_LARGE", details) {
-    super(message, "JOB_REQUEST_TOO_LARGE", 413, errorCode, details);
-  }
-};
-var JobTimeoutError = class extends JobsClientError {
-  constructor(message, details) {
-    super(message, "JOB_TIMEOUT", void 0, null, details);
-  }
-};
-var JobRejectedError = class extends JobsClientError {
-  constructor(message, status, errorCode = null, details) {
-    super(message, "JOB_REJECTED", status, errorCode, details);
-  }
-};
-var JobTransportError = class extends JobsClientError {
-  constructor(message, cause) {
-    super(message, "JOB_TRANSPORT_ERROR");
-    this.cause = cause;
-  }
-};
-var LineageReadError = class extends VanaError {
-  constructor(message, status, errorCode = null, details) {
-    super(message, "LINEAGE_READ_ERROR");
-    this.status = status;
-    this.errorCode = errorCode;
-    this.details = details;
-  }
-  status;
-  errorCode;
-  details;
-};
-var DerivativeQuestionRejectedError = class extends PersonalServerWriteError {
-  constructor(message, status, errorCode = null, details) {
-    super(message, "DERIVATIVE_QUESTION_REJECTED", status, errorCode, details);
-  }
-};
-var DerivativeQuestionInvalidError = class extends PersonalServerWriteError {
-  constructor(message, status = 400, errorCode = null, details) {
-    super(message, "DERIVATIVE_QUESTION_INVALID", status, errorCode, details);
-  }
-};
-var DerivativeQuestionNotFoundError = class extends PersonalServerWriteError {
-  constructor(message, errorCode = null, details) {
-    super(message, "DERIVATIVE_QUESTION_NOT_FOUND", 404, errorCode, details);
-  }
-};
-var DerivativeDerivedScopeRequiredError = class extends PersonalServerWriteError {
-  constructor(message, errorCode = null, details) {
-    super(
-      message,
-      "DERIVATIVE_DERIVED_SCOPE_REQUIRED",
-      400,
-      errorCode,
-      details
-    );
-  }
-};
-var DerivativeSourceNotGrantedError = class extends PersonalServerWriteError {
-  constructor(message, errorCode = null, details) {
-    super(message, "DERIVATIVE_SOURCE_NOT_GRANTED", 403, errorCode, details);
-  }
-};
-var DerivativeCycleError = class extends PersonalServerWriteError {
-  constructor(message, errorCode = null, details) {
-    super(message, "DERIVATIVE_CYCLE", 409, errorCode, details);
-  }
-};
-var DerivativeComputeUnavailableError = class extends PersonalServerWriteError {
-  constructor(message, errorCode = null, details) {
-    super(message, "DERIVATIVE_COMPUTE_UNAVAILABLE", 503, errorCode, details);
-  }
-};
-var DerivativeQuestionTimeoutError = class extends PersonalServerWriteError {
-  constructor(message, details) {
-    super(message, "DERIVATIVE_QUESTION_TIMEOUT", void 0, null, details);
-  }
-};
-var DerivativeQuestionFailedError = class extends PersonalServerWriteError {
-  constructor(message, details) {
-    super(message, "DERIVATIVE_QUESTION_FAILED", void 0, null, details);
-  }
-};
-var DataPointDeletedError = class extends VanaError {
-  constructor(message, details = {}) {
-    super(message, "DATA_POINT_DELETED");
-    this.details = details;
-  }
-  details;
-};
-var DataPointNotFoundError = class extends VanaError {
-  constructor(message, details = {}) {
-    super(message, "DATA_POINT_NOT_FOUND");
-    this.details = details;
-  }
-  details;
-};
-var DataPointVersionConflictError = class extends VanaError {
-  constructor(message, details = {}) {
-    super(message, "DATA_POINT_VERSION_CONFLICT");
-    this.details = details;
-  }
-  details;
-};
+__reExport(index_node_exports, require("./errors.cjs"), module.exports);
 
 // src/contracts/contractController.ts
 var import_viem3 = require("viem");
@@ -32182,31 +31803,7 @@ async function decryptWithPassword(encrypted, password) {
 
 // src/auth/web3-signed.ts
 var import_viem13 = require("viem");
-
-// src/auth/errors.ts
-var MissingAuthError = class extends VanaError {
-  constructor(message = "Missing authentication", details) {
-    super(message, "MISSING_AUTH");
-    this.details = details;
-  }
-  details;
-};
-var InvalidSignatureError = class extends VanaError {
-  constructor(details, message = "Invalid signature") {
-    super(message, "INVALID_SIGNATURE");
-    this.details = details;
-  }
-  details;
-};
-var ExpiredTokenError = class extends VanaError {
-  constructor(details, message = "Token has expired") {
-    super(message, "EXPIRED_TOKEN");
-    this.details = details;
-  }
-  details;
-};
-
-// src/auth/web3-signed.ts
+var import_errors = require("./auth/errors.cjs");
 var WEB3_SIGNED_PREFIX = "Web3Signed ";
 var CLOCK_SKEW_SECONDS = 60;
 function base64urlDecode(input) {
@@ -32220,14 +31817,14 @@ function isFiniteNumber(value) {
 }
 function parsePayload(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
-    throw new InvalidSignatureError({ reason: "Invalid payload shape" });
+    throw new import_errors.InvalidSignatureError({ reason: "Invalid payload shape" });
   }
   const payload = value;
   if (typeof payload["aud"] !== "string" || typeof payload["method"] !== "string" || typeof payload["uri"] !== "string" || typeof payload["bodyHash"] !== "string" || !isFiniteNumber(payload["iat"]) || !isFiniteNumber(payload["exp"])) {
-    throw new InvalidSignatureError({ reason: "Invalid payload claims" });
+    throw new import_errors.InvalidSignatureError({ reason: "Invalid payload claims" });
   }
   if (payload["grantId"] !== void 0 && typeof payload["grantId"] !== "string") {
-    throw new InvalidSignatureError({ reason: "Invalid grantId claim" });
+    throw new import_errors.InvalidSignatureError({ reason: "Invalid grantId claim" });
   }
   return {
     aud: payload["aud"],
@@ -32241,28 +31838,28 @@ function parsePayload(value) {
 }
 function parseWeb3SignedHeader(headerValue) {
   if (!headerValue) {
-    throw new MissingAuthError();
+    throw new import_errors.MissingAuthError();
   }
   if (!headerValue.startsWith(WEB3_SIGNED_PREFIX)) {
-    throw new InvalidSignatureError({ reason: "Missing Web3Signed prefix" });
+    throw new import_errors.InvalidSignatureError({ reason: "Missing Web3Signed prefix" });
   }
   const value = headerValue.slice(WEB3_SIGNED_PREFIX.length);
   const dotIndex = value.indexOf(".");
   if (dotIndex === -1 || dotIndex === 0 || dotIndex === value.length - 1) {
-    throw new InvalidSignatureError({ reason: "Invalid header format" });
+    throw new import_errors.InvalidSignatureError({ reason: "Invalid header format" });
   }
   const payloadBase64 = value.slice(0, dotIndex);
   const signatureStr = value.slice(dotIndex + 1);
   if (!signatureStr.startsWith("0x")) {
-    throw new InvalidSignatureError({ reason: "Invalid signature format" });
+    throw new import_errors.InvalidSignatureError({ reason: "Invalid signature format" });
   }
   let payload;
   try {
     const decoded = base64urlDecode(payloadBase64);
     payload = parsePayload(JSON.parse(decoded));
   } catch (err) {
-    if (err instanceof InvalidSignatureError) throw err;
-    throw new InvalidSignatureError({ reason: "Invalid payload encoding" });
+    if (err instanceof import_errors.InvalidSignatureError) throw err;
+    throw new import_errors.InvalidSignatureError({ reason: "Invalid payload encoding" });
   }
   return {
     payloadBase64,
@@ -32281,24 +31878,24 @@ async function verifyWeb3Signed(params) {
       signature
     });
   } catch {
-    throw new InvalidSignatureError({ reason: "Signature recovery failed" });
+    throw new import_errors.InvalidSignatureError({ reason: "Signature recovery failed" });
   }
   if (payload.aud !== params.expectedOrigin) {
-    throw new InvalidSignatureError({
+    throw new import_errors.InvalidSignatureError({
       reason: "Audience mismatch",
       expected: params.expectedOrigin,
       actual: payload.aud
     });
   }
   if (payload.method !== params.expectedMethod) {
-    throw new InvalidSignatureError({
+    throw new import_errors.InvalidSignatureError({
       reason: "Method mismatch",
       expected: params.expectedMethod,
       actual: payload.method
     });
   }
   if (payload.uri !== params.expectedPath) {
-    throw new InvalidSignatureError({
+    throw new import_errors.InvalidSignatureError({
       reason: "URI mismatch",
       expected: params.expectedPath,
       actual: payload.uri
@@ -32307,7 +31904,7 @@ async function verifyWeb3Signed(params) {
   if (params.bodyBytes !== void 0) {
     const expectedBodyHash = computeBodyHash(params.bodyBytes);
     if (payload.bodyHash !== expectedBodyHash) {
-      throw new InvalidSignatureError({
+      throw new import_errors.InvalidSignatureError({
         reason: "Body hash mismatch",
         expected: expectedBodyHash,
         actual: payload.bodyHash
@@ -32316,14 +31913,17 @@ async function verifyWeb3Signed(params) {
   }
   const now = params.now ?? Math.floor(Date.now() / 1e3);
   if (payload.exp < now - CLOCK_SKEW_SECONDS) {
-    throw new ExpiredTokenError({ reason: "Token expired" });
+    throw new import_errors.ExpiredTokenError({ reason: "Token expired" });
   }
   if (payload.iat > now + CLOCK_SKEW_SECONDS) {
-    throw new ExpiredTokenError({ reason: "Token issued in the future" });
+    throw new import_errors.ExpiredTokenError({ reason: "Token issued in the future" });
   }
   return { signer, payload };
 }
 
+// src/index.node.ts
+var import_errors14 = require("./auth/errors.cjs");
+
 // src/auth/pkce.ts
 var PKCE_VERIFIER_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~";
 var PKCE_VERIFIER_MIN_LENGTH = 43;
@@ -32691,6 +32291,9 @@ function escrowPaymentDomain(config) {
     config.contracts.dataPortabilityEscrow
   );
 }
+function withdrawAuthorizationDomain(config) {
+  return escrowPaymentDomain(config);
+}
 var GRANT_REGISTRATION_TYPES = {
   GrantRegistration: [
     { name: "grantorAddress", type: "address" },
@@ -32723,6 +32326,15 @@ var BUILDER_REGISTRATION_TYPES = {
     { name: "appUrl", type: "string" }
   ]
 };
+var WITHDRAW_AUTHORIZATION_TYPES = {
+  WithdrawAuthorization: [
+    { name: "account", type: "address" },
+    { name: "asset", type: "address" },
+    { name: "amount", type: "uint256" },
+    { name: "withdrawNonce", type: "uint256" },
+    { name: "deadline", type: "uint256" }
+  ]
+};
 var ADD_DATA_TYPES = {
   AddData: [
     { name: "ownerAddress", type: "address" },
@@ -32741,6 +32353,14 @@ var RECORD_DATA_ACCESS_TYPES = {
     { name: "recordId", type: "bytes32" }
   ]
 };
+function buildWithdrawAuthorizationTypedData(config, message) {
+  return {
+    domain: withdrawAuthorizationDomain(config),
+    types: WITHDRAW_AUTHORIZATION_TYPES,
+    primaryType: "WithdrawAuthorization",
+    message
+  };
+}
 
 // src/protocol/identity.ts
 var secp256k14 = __toESM(require("@noble/secp256k1"), 1);
@@ -32769,8 +32389,13 @@ function emptyAnchor() {
 var ENCLAVE_TRUST_ANCHORS = Object.freeze({
   // filled at fleet provisioning; verify fails closed while empty
   [VANA_MAINNET_CHAIN_ID]: emptyAnchor(),
-  // filled at fleet provisioning; verify fails closed while empty
-  [MOKSHA_CHAIN_ID]: emptyAnchor()
+  // Moksha workers share this dstack app and KMS root; the controller does not derive owner keys.
+  [MOKSHA_CHAIN_ID]: Object.freeze({
+    kmsRootPubkey: "0x0434c76e0c3f52ec64cbf9bbf5c910c272330166fd656c0a86bb330963e46910e1a0e6fa51bec74be2f9129342707636060d85856d102cee8290185409ecf7422f",
+    appIds: Object.freeze([
+      "0xec9a39de98c760e1ded9f1e97016dc5f0e357cf2"
+    ])
+  })
 });
 function userPsId(chainId, ownerAddress) {
   const packed = (0, import_viem14.encodePacked)(
@@ -32917,21 +32542,36 @@ var MAX_LEASE_SECONDS = 300;
 var MAX_ATTEMPTS = 3;
 var MAX_WAIT_SECONDS = 25;
 var CLAIM_POLL_FLOOR_MS = 1e3;
-var MAX_INLINE_RESULT_BYTES = 1048576;
 var DEFAULT_JOB_DEADLINE_SECONDS = 600;
 var MAX_JOB_DEADLINE_SECONDS = 3600;
 
 // src/protocol/jobs-client.ts
 var import_node_crypto = require("node:crypto");
+var import_sha26 = require("@noble/hashes/sha2");
 var import_viem16 = require("viem");
 var import_accounts2 = require("viem/accounts");
 
 // src/crypto/envelope/job.ts
 var import_sha25 = require("@noble/hashes/sha2");
 var import_viem15 = require("viem");
+init_constants();
 init_interface();
 var textDecoder = new TextDecoder();
 var textEncoder = new TextEncoder();
+var MAX_JOB_RESULT_HEADER_BYTES = 4096;
+var WRAPPED_KEY_LENGTH_BYTES = 4;
+var FRAME_LENGTH_BYTES = 4;
+var FRAME_FLAGS_BYTES = 1;
+var AES_KEY_BYTES = 32;
+var AES_GCM_NONCE_BYTES = 12;
+var AES_GCM_TAG_BYTES = 16;
+var WRAPPED_METADATA_LENGTH_BYTES = 4;
+var WRAPPED_KEY_PLAINTEXT_PREFIX_BYTES = AES_KEY_BYTES + AES_GCM_NONCE_BYTES + WRAPPED_METADATA_LENGTH_BYTES;
+var MAX_WRAPPED_KEY_BYTES = 8192;
+var FINAL_FRAME_FLAG = 1;
+var MAX_CHUNK_INDEX = 4294967295;
+var JOB_RESULT_FORMAT_VERSION = 2;
+var JOB_RESULT_CHUNK_BYTES = 1024 * 1024;
 var JobEnvelopeError = class extends Error {
   constructor(message) {
     super(message);
@@ -32963,21 +32603,68 @@ function requestPlaintext(envelope) {
   validateRequestEnvelope(envelope);
   return canonicalJsonBytes(envelope);
 }
-function resultPlaintext(result) {
-  return textEncoder.encode(
-    JSON.stringify({
-      v: result.v,
-      jobId: result.jobId,
-      scope: result.scope,
-      version: result.version,
-      contentType: result.contentType,
-      body: result.body
-    })
-  );
+function resultMetadata(result) {
+  return {
+    v: result.v,
+    jobId: result.jobId,
+    scope: result.scope,
+    version: result.version,
+    contentType: result.contentType
+  };
 }
 function encryptedBytesToBase64(encrypted) {
   return toBase64((0, import_viem15.fromHex)(`0x${serializeECIES(encrypted)}`, "bytes"));
 }
+function encryptedToBytes(encrypted) {
+  const bytes = new Uint8Array(
+    encrypted.iv.length + encrypted.ephemPublicKey.length + encrypted.ciphertext.length + encrypted.mac.length
+  );
+  let offset = 0;
+  bytes.set(encrypted.iv, offset);
+  offset += encrypted.iv.length;
+  bytes.set(encrypted.ephemPublicKey, offset);
+  offset += encrypted.ephemPublicKey.length;
+  bytes.set(encrypted.ciphertext, offset);
+  offset += encrypted.ciphertext.length;
+  bytes.set(encrypted.mac, offset);
+  return bytes;
+}
+function bytesToEncrypted(bytes) {
+  const absoluteMinLength = FORMAT.IV_LENGTH + 1 + MAC.LENGTH + 1;
+  if (bytes.length < absoluteMinLength) {
+    throw new ECIESError(
+      `Invalid ECIES data: too short (${bytes.length} bytes, minimum ${absoluteMinLength} bytes required)`,
+      "DECRYPTION_FAILED"
+    );
+  }
+  const prefix = bytes[FORMAT.EPHEMERAL_KEY_OFFSET];
+  if (prefix !== CURVE.PREFIX.UNCOMPRESSED) {
+    throw new ECIESError(
+      `Invalid ephemeral public key: must be uncompressed format (0x04 prefix), got 0x${prefix.toString(16).padStart(2, "0")}`,
+      "DECRYPTION_FAILED"
+    );
+  }
+  const ephemKeySize = CURVE.UNCOMPRESSED_PUBLIC_KEY_LENGTH;
+  const minLength = FORMAT.IV_LENGTH + ephemKeySize + MAC.LENGTH + 1;
+  if (bytes.length < minLength) {
+    throw new ECIESError(
+      `Invalid ECIES data: too short (${bytes.length} bytes, minimum ${minLength} bytes required)`,
+      "DECRYPTION_FAILED"
+    );
+  }
+  return {
+    iv: bytes.subarray(FORMAT.IV_OFFSET, FORMAT.IV_OFFSET + FORMAT.IV_LENGTH),
+    ephemPublicKey: bytes.subarray(
+      FORMAT.EPHEMERAL_KEY_OFFSET,
+      FORMAT.EPHEMERAL_KEY_OFFSET + ephemKeySize
+    ),
+    ciphertext: bytes.subarray(
+      FORMAT.EPHEMERAL_KEY_OFFSET + ephemKeySize,
+      bytes.length - MAC.LENGTH
+    ),
+    mac: bytes.subarray(bytes.length - MAC.LENGTH)
+  };
+}
 function base64ToEncrypted(ciphertext) {
   return deserializeECIES((0, import_viem15.toHex)(fromBase64(ciphertext)));
 }
@@ -33078,11 +32765,11 @@ function validateRequestEnvelope(value) {
   requireString(value.auth, "auth", "job request envelope");
   return value;
 }
-function validateResult(value) {
-  requirePlainObject(value, "result", "job result");
+function validateResultMetadata(value) {
+  requirePlainObject(value, "metadata", "job result");
   requireExactKeys(
     value,
-    ["v", "jobId", "scope", "version", "contentType", "body"],
+    ["v", "jobId", "scope", "version", "contentType"],
     "job result"
   );
   if (value.v !== JOB_PROTOCOL_VERSION) {
@@ -33093,14 +32780,222 @@ function validateResult(value) {
   for (const field of ["jobId", "scope", "contentType"]) {
     requireString(value[field], field, "job result");
   }
-  if (typeof value.body !== "string") {
-    throw new JobEnvelopeError("Invalid job result: missing body");
-  }
   if (value.version !== null && typeof value.version !== "string") {
     throw new JobEnvelopeError("Invalid job result: missing version");
   }
   return value;
 }
+function validateResult(value) {
+  requirePlainObject(value, "result", "job result");
+  requireExactKeys(
+    value,
+    ["v", "jobId", "scope", "version", "contentType", "body"],
+    "job result"
+  );
+  validateResultMetadata(resultMetadata(value));
+  if (!(value.body instanceof Uint8Array)) {
+    throw new JobEnvelopeError("Invalid job result: missing body");
+  }
+  return value;
+}
+function webCrypto() {
+  if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.getRandomValues !== "function" || !globalThis.crypto.subtle) {
+    throw new JobEnvelopeError(
+      "Job result streaming requires the Web Crypto API"
+    );
+  }
+  return globalThis.crypto;
+}
+function uint32(value) {
+  const bytes = new Uint8Array(4);
+  new DataView(bytes.buffer).setUint32(0, value);
+  return bytes;
+}
+function readUint32(bytes, offset = 0) {
+  return new DataView(bytes.buffer, bytes.byteOffset + offset, 4).getUint32(0);
+}
+function wrappedKeyPlaintext(contentKey, noncePrefix, metadataBytes) {
+  const plaintext = new Uint8Array(
+    WRAPPED_KEY_PLAINTEXT_PREFIX_BYTES + metadataBytes.length
+  );
+  plaintext.set(contentKey, 0);
+  plaintext.set(noncePrefix, AES_KEY_BYTES);
+  new DataView(plaintext.buffer).setUint32(
+    AES_KEY_BYTES + AES_GCM_NONCE_BYTES,
+    metadataBytes.length
+  );
+  plaintext.set(metadataBytes, WRAPPED_KEY_PLAINTEXT_PREFIX_BYTES);
+  return plaintext;
+}
+function parseWrappedKeyPlaintext(plaintext) {
+  if (plaintext.length < WRAPPED_KEY_PLAINTEXT_PREFIX_BYTES) {
+    throw new JobEnvelopeError("Invalid job result: wrapped key is truncated");
+  }
+  const metadataLength = readUint32(
+    plaintext,
+    AES_KEY_BYTES + AES_GCM_NONCE_BYTES
+  );
+  if (metadataLength > MAX_JOB_RESULT_HEADER_BYTES) {
+    throw new JobEnvelopeError(
+      `Invalid job result: header exceeds ${MAX_JOB_RESULT_HEADER_BYTES} bytes`
+    );
+  }
+  if (plaintext.length !== WRAPPED_KEY_PLAINTEXT_PREFIX_BYTES + metadataLength) {
+    throw new JobEnvelopeError(
+      "Invalid job result: header length exceeds payload"
+    );
+  }
+  const metadataBytes = plaintext.slice(WRAPPED_KEY_PLAINTEXT_PREFIX_BYTES);
+  const metadata = validateResultMetadata(
+    parseObject(metadataBytes, "job result header")
+  );
+  return {
+    contentKey: plaintext.slice(0, AES_KEY_BYTES),
+    noncePrefix: plaintext.slice(
+      AES_KEY_BYTES,
+      AES_KEY_BYTES + AES_GCM_NONCE_BYTES
+    ),
+    metadataBytes,
+    metadata
+  };
+}
+async function importAesKey(contentKey, usage) {
+  return webCrypto().subtle.importKey(
+    "raw",
+    contentKey,
+    { name: "AES-GCM" },
+    false,
+    [usage]
+  );
+}
+function chunkNonce(noncePrefix, chunkIndex) {
+  if (chunkIndex > MAX_CHUNK_INDEX) {
+    throw new JobEnvelopeError("Invalid job result: too many chunks");
+  }
+  const nonce = noncePrefix.slice();
+  const view = new DataView(nonce.buffer, nonce.byteOffset, nonce.byteLength);
+  view.setUint32(8, view.getUint32(8) ^ chunkIndex);
+  return nonce;
+}
+function chunkAad(metadataBytes, chunkIndex, final, plaintextLength) {
+  const aad = new Uint8Array(14 + metadataBytes.length);
+  aad[0] = JOB_RESULT_FORMAT_VERSION;
+  aad.set(uint32(metadataBytes.length), 1);
+  aad.set(metadataBytes, 5);
+  aad.set(uint32(chunkIndex), 5 + metadataBytes.length);
+  aad[9 + metadataBytes.length] = final ? FINAL_FRAME_FLAG : 0;
+  aad.set(uint32(plaintextLength), 10 + metadataBytes.length);
+  return aad;
+}
+async function encryptResultChunk(key, noncePrefix, metadataBytes, plaintext, chunkIndex, final) {
+  const encrypted = new Uint8Array(
+    await webCrypto().subtle.encrypt(
+      {
+        name: "AES-GCM",
+        iv: chunkNonce(noncePrefix, chunkIndex),
+        additionalData: chunkAad(
+          metadataBytes,
+          chunkIndex,
+          final,
+          plaintext.length
+        ),
+        tagLength: AES_GCM_TAG_BYTES * 8
+      },
+      key,
+      plaintext
+    )
+  );
+  const frame = new Uint8Array(
+    FRAME_LENGTH_BYTES + FRAME_FLAGS_BYTES + encrypted.length
+  );
+  new DataView(frame.buffer).setUint32(0, encrypted.length);
+  frame[FRAME_LENGTH_BYTES] = final ? FINAL_FRAME_FLAG : 0;
+  frame.set(encrypted, FRAME_LENGTH_BYTES + FRAME_FLAGS_BYTES);
+  return frame;
+}
+function verifyResultBindings(metadata, expect) {
+  if (metadata.jobId !== expect.jobId) {
+    throw new JobEnvelopeError(
+      `Job result ID ${metadata.jobId} does not match expected job ID ${expect.jobId}`
+    );
+  }
+  if (expect.scope !== void 0 && metadata.scope !== expect.scope) {
+    throw new JobEnvelopeError(
+      `Job result scope ${metadata.scope} does not match expected scope ${expect.scope}`
+    );
+  }
+  if (expect.version !== void 0 && metadata.version !== expect.version) {
+    throw new JobEnvelopeError(
+      `Job result version ${String(metadata.version)} does not match expected version ${String(expect.version)}`
+    );
+  }
+}
+var ByteStreamReader = class {
+  reader;
+  current;
+  offset = 0;
+  ended = false;
+  constructor(stream) {
+    this.reader = stream.getReader();
+  }
+  async ensureBytes() {
+    while (!this.current || this.offset === this.current.length) {
+      if (this.ended) return false;
+      const next = await this.reader.read();
+      if (next.done) {
+        this.ended = true;
+        this.current = void 0;
+        return false;
+      }
+      if (!(next.value instanceof Uint8Array)) {
+        throw new JobEnvelopeError(
+          "Invalid job result: stream yielded non-byte data"
+        );
+      }
+      this.current = next.value;
+      this.offset = 0;
+    }
+    return true;
+  }
+  async readExactOrNull(length) {
+    if (!await this.ensureBytes()) return null;
+    const bytes = new Uint8Array(length);
+    let written = 0;
+    while (written < length) {
+      if (!await this.ensureBytes()) {
+        throw new JobEnvelopeError("Invalid job result: truncated payload");
+      }
+      const available = this.current.length - this.offset;
+      const count = Math.min(available, length - written);
+      bytes.set(
+        this.current.subarray(this.offset, this.offset + count),
+        written
+      );
+      this.offset += count;
+      written += count;
+    }
+    return bytes;
+  }
+  async readExact(length) {
+    const bytes = await this.readExactOrNull(length);
+    if (!bytes) {
+      throw new JobEnvelopeError("Invalid job result: truncated payload");
+    }
+    return bytes;
+  }
+  async hasRemaining() {
+    return this.ensureBytes();
+  }
+  async cancel(reason) {
+    await this.reader.cancel(reason);
+  }
+};
+function normalizeChunkError(error) {
+  if (error instanceof JobEnvelopeError) return error;
+  return new JobEnvelopeError(
+    `Invalid job result: chunk authentication failed${error instanceof Error ? `: ${error.message}` : ""}`
+  );
+}
 async function sealJobRequest(envelope, enclavePublicKey, ecies) {
   const encrypted = await ecies.encrypt(
     (0, import_viem15.fromHex)(enclavePublicKey, "bytes"),
@@ -33117,41 +33012,322 @@ async function openJobRequest(ciphertext, privateKey, ecies) {
     parseObject(plaintext, "job request envelope")
   );
 }
-async function sealJobResult(result, builderPublicKey, ecies) {
-  validateResult(result);
-  const encrypted = await ecies.encrypt(
+async function sealJobResultStream(metadataValue, builderPublicKey, ecies) {
+  const metadata = validateResultMetadata(metadataValue);
+  const metadataBytes = canonicalJsonBytes(metadata);
+  if (metadataBytes.length > MAX_JOB_RESULT_HEADER_BYTES) {
+    throw new JobEnvelopeError(
+      `Invalid job result: header exceeds ${MAX_JOB_RESULT_HEADER_BYTES} bytes`
+    );
+  }
+  const crypto2 = webCrypto();
+  const contentKey = crypto2.getRandomValues(new Uint8Array(AES_KEY_BYTES));
+  const noncePrefix = crypto2.getRandomValues(
+    new Uint8Array(AES_GCM_NONCE_BYTES)
+  );
+  const key = await importAesKey(contentKey, "encrypt");
+  const keyPlaintext = wrappedKeyPlaintext(
+    contentKey,
+    noncePrefix,
+    metadataBytes
+  );
+  const encryptedKey = await ecies.encrypt(
     (0, import_viem15.fromHex)(builderPublicKey, "bytes"),
-    resultPlaintext(result)
+    keyPlaintext
+  );
+  contentKey.fill(0);
+  keyPlaintext.fill(0);
+  const wrappedKey = encryptedToBytes(encryptedKey);
+  if (wrappedKey.length > MAX_WRAPPED_KEY_BYTES) {
+    throw new JobEnvelopeError("Invalid job result: wrapped key is too large");
+  }
+  const header = new Uint8Array(
+    1 + WRAPPED_KEY_LENGTH_BYTES + wrappedKey.length
   );
-  const ciphertext = encryptedBytesToBase64(encrypted);
-  const bytes = fromBase64(ciphertext);
-  return { ciphertext, hash: (0, import_viem15.bytesToHex)((0, import_sha25.sha256)(bytes)), size: bytes.length };
+  header[0] = JOB_RESULT_FORMAT_VERSION;
+  new DataView(header.buffer).setUint32(1, wrappedKey.length);
+  header.set(wrappedKey, 1 + WRAPPED_KEY_LENGTH_BYTES);
+  let pending = new Uint8Array(JOB_RESULT_CHUNK_BYTES);
+  let pendingLength = 0;
+  let chunkIndex = 0;
+  const transform = new TransformStream({
+    async transform(chunk, controller) {
+      if (!(chunk instanceof Uint8Array)) {
+        throw new JobEnvelopeError(
+          "Invalid job result: stream yielded non-byte data"
+        );
+      }
+      let offset = 0;
+      while (offset < chunk.length) {
+        if (pendingLength === JOB_RESULT_CHUNK_BYTES) {
+          controller.enqueue(
+            await encryptResultChunk(
+              key,
+              noncePrefix,
+              metadataBytes,
+              pending,
+              chunkIndex,
+              false
+            )
+          );
+          chunkIndex += 1;
+          pending = new Uint8Array(JOB_RESULT_CHUNK_BYTES);
+          pendingLength = 0;
+        }
+        const count = Math.min(
+          chunk.length - offset,
+          JOB_RESULT_CHUNK_BYTES - pendingLength
+        );
+        pending.set(chunk.subarray(offset, offset + count), pendingLength);
+        pendingLength += count;
+        offset += count;
+      }
+    },
+    async flush(controller) {
+      controller.enqueue(
+        await encryptResultChunk(
+          key,
+          noncePrefix,
+          metadataBytes,
+          pending.subarray(0, pendingLength),
+          chunkIndex,
+          true
+        )
+      );
+    }
+  });
+  return { header, transform };
 }
-async function openJobResult(ciphertext, builderPrivateKey, ecies, expect) {
-  const plaintext = await ecies.decrypt(
-    (0, import_viem15.fromHex)(builderPrivateKey, "bytes"),
-    base64ToEncrypted(ciphertext)
+async function sealJobResult(result, builderPublicKey, ecies) {
+  validateResult(result);
+  const sealed = await sealJobResultStream(
+    resultMetadata(result),
+    builderPublicKey,
+    ecies
+  );
+  const frameCount = Math.max(
+    1,
+    Math.ceil(result.body.length / JOB_RESULT_CHUNK_BYTES)
   );
-  const result = validateResult(parseObject(plaintext, "job result"));
-  if (result.jobId !== expect.jobId) {
+  const size = sealed.header.length + result.body.length + frameCount * (FRAME_LENGTH_BYTES + FRAME_FLAGS_BYTES + AES_GCM_TAG_BYTES);
+  const bytes = new Uint8Array(size);
+  bytes.set(sealed.header, 0);
+  let outputOffset = sealed.header.length;
+  const reader = sealed.transform.readable.getReader();
+  const drain = (async () => {
+    for (; ; ) {
+      const next = await reader.read();
+      if (next.done) break;
+      bytes.set(next.value, outputOffset);
+      outputOffset += next.value.length;
+    }
+  })();
+  const writer = sealed.transform.writable.getWriter();
+  const fill = (async () => {
+    for (let offset = 0; offset < result.body.length; offset += JOB_RESULT_CHUNK_BYTES) {
+      await writer.write(
+        result.body.subarray(offset, offset + JOB_RESULT_CHUNK_BYTES)
+      );
+    }
+    await writer.close();
+  })();
+  await Promise.all([drain, fill]);
+  if (outputOffset !== bytes.length) {
+    throw new JobEnvelopeError("Invalid job result: sealed size mismatch");
+  }
+  return { bytes, hash: (0, import_viem15.bytesToHex)((0, import_sha25.sha256)(bytes)), size };
+}
+async function openJobResultStream(bytesStream, builderPrivateKey, ecies, expect) {
+  const reader = new ByteStreamReader(bytesStream);
+  const headerPrefix = await reader.readExact(1 + WRAPPED_KEY_LENGTH_BYTES);
+  const formatVersion = headerPrefix[0];
+  if (formatVersion !== JOB_RESULT_FORMAT_VERSION) {
     throw new JobEnvelopeError(
-      `Job result ID ${result.jobId} does not match expected job ID ${expect.jobId}`
+      `Unsupported job result format: ${String(formatVersion)}`
     );
   }
-  if (expect.scope !== void 0 && result.scope !== expect.scope) {
+  const wrappedKeyLength = readUint32(headerPrefix, 1);
+  if (wrappedKeyLength === 0 || wrappedKeyLength > MAX_WRAPPED_KEY_BYTES) {
     throw new JobEnvelopeError(
-      `Job result scope ${result.scope} does not match expected scope ${expect.scope}`
+      "Invalid job result: invalid wrapped key length"
     );
   }
-  if (expect.version !== void 0 && result.version !== expect.version) {
+  const wrappedKey = await reader.readExact(wrappedKeyLength);
+  const keyPlaintext = await ecies.decrypt(
+    (0, import_viem15.fromHex)(builderPrivateKey, "bytes"),
+    bytesToEncrypted(wrappedKey)
+  );
+  const parsed = parseWrappedKeyPlaintext(keyPlaintext);
+  verifyResultBindings(parsed.metadata, expect);
+  const key = await importAesKey(parsed.contentKey, "decrypt");
+  parsed.contentKey.fill(0);
+  keyPlaintext.fill(0);
+  let chunkIndex = 0;
+  let finished = false;
+  const body = new ReadableStream({
+    async pull(controller) {
+      if (finished) {
+        controller.close();
+        return;
+      }
+      try {
+        const frameHeader = await reader.readExactOrNull(
+          FRAME_LENGTH_BYTES + FRAME_FLAGS_BYTES
+        );
+        if (!frameHeader) {
+          throw new JobEnvelopeError("Invalid job result: missing final chunk");
+        }
+        const encryptedLength = readUint32(frameHeader);
+        if (encryptedLength < AES_GCM_TAG_BYTES || encryptedLength > JOB_RESULT_CHUNK_BYTES + AES_GCM_TAG_BYTES) {
+          throw new JobEnvelopeError(
+            "Invalid job result: invalid chunk length"
+          );
+        }
+        const flags = frameHeader[FRAME_LENGTH_BYTES];
+        if (flags !== 0 && flags !== FINAL_FRAME_FLAG) {
+          throw new JobEnvelopeError("Invalid job result: invalid chunk flags");
+        }
+        const final = flags === FINAL_FRAME_FLAG;
+        const plaintextLength = encryptedLength - AES_GCM_TAG_BYTES;
+        if (!final && plaintextLength !== JOB_RESULT_CHUNK_BYTES) {
+          throw new JobEnvelopeError(
+            "Invalid job result: short non-final chunk"
+          );
+        }
+        const encrypted = await reader.readExact(encryptedLength);
+        const plaintext = new Uint8Array(
+          await webCrypto().subtle.decrypt(
+            {
+              name: "AES-GCM",
+              iv: chunkNonce(parsed.noncePrefix, chunkIndex),
+              additionalData: chunkAad(
+                parsed.metadataBytes,
+                chunkIndex,
+                final,
+                plaintextLength
+              ),
+              tagLength: AES_GCM_TAG_BYTES * 8
+            },
+            key,
+            encrypted
+          )
+        );
+        if (plaintext.length !== plaintextLength) {
+          throw new JobEnvelopeError(
+            "Invalid job result: decrypted chunk length mismatch"
+          );
+        }
+        chunkIndex += 1;
+        if (final) {
+          if (await reader.hasRemaining()) {
+            throw new JobEnvelopeError(
+              "Invalid job result: bytes follow final chunk"
+            );
+          }
+          finished = true;
+        }
+        controller.enqueue(plaintext);
+        if (finished) controller.close();
+      } catch (error) {
+        controller.error(normalizeChunkError(error));
+        void reader.cancel(error).catch(() => void 0);
+      }
+    },
+    cancel(reason) {
+      return reader.cancel(reason);
+    }
+  });
+  return { metadata: parsed.metadata, body };
+}
+function bufferedResultBodySize(sealedBytes) {
+  if (sealedBytes.length < 1 + WRAPPED_KEY_LENGTH_BYTES) {
+    throw new JobEnvelopeError("Invalid job result: truncated payload");
+  }
+  if (sealedBytes[0] !== JOB_RESULT_FORMAT_VERSION) {
     throw new JobEnvelopeError(
-      `Job result version ${String(result.version)} does not match expected version ${String(expect.version)}`
+      `Unsupported job result format: ${String(sealedBytes[0])}`
     );
   }
-  return result;
+  const wrappedKeyLength = readUint32(sealedBytes, 1);
+  if (wrappedKeyLength === 0 || wrappedKeyLength > MAX_WRAPPED_KEY_BYTES) {
+    throw new JobEnvelopeError(
+      "Invalid job result: invalid wrapped key length"
+    );
+  }
+  let offset = 1 + WRAPPED_KEY_LENGTH_BYTES + wrappedKeyLength;
+  if (offset > sealedBytes.length) {
+    throw new JobEnvelopeError("Invalid job result: truncated payload");
+  }
+  let bodySize = 0;
+  let sawFinal = false;
+  while (offset < sealedBytes.length) {
+    if (sealedBytes.length - offset < FRAME_LENGTH_BYTES + FRAME_FLAGS_BYTES) {
+      throw new JobEnvelopeError("Invalid job result: truncated payload");
+    }
+    const encryptedLength = readUint32(sealedBytes, offset);
+    const flags = sealedBytes[offset + FRAME_LENGTH_BYTES];
+    if (encryptedLength < AES_GCM_TAG_BYTES || encryptedLength > JOB_RESULT_CHUNK_BYTES + AES_GCM_TAG_BYTES || flags !== 0 && flags !== FINAL_FRAME_FLAG) {
+      throw new JobEnvelopeError("Invalid job result: invalid chunk framing");
+    }
+    const plaintextLength = encryptedLength - AES_GCM_TAG_BYTES;
+    if (flags === 0 && plaintextLength !== JOB_RESULT_CHUNK_BYTES) {
+      throw new JobEnvelopeError("Invalid job result: short non-final chunk");
+    }
+    offset += FRAME_LENGTH_BYTES + FRAME_FLAGS_BYTES;
+    if (encryptedLength > sealedBytes.length - offset) {
+      throw new JobEnvelopeError("Invalid job result: truncated payload");
+    }
+    offset += encryptedLength;
+    bodySize += plaintextLength;
+    if (flags === FINAL_FRAME_FLAG) {
+      sawFinal = true;
+      if (offset !== sealedBytes.length) {
+        throw new JobEnvelopeError(
+          "Invalid job result: bytes follow final chunk"
+        );
+      }
+    }
+  }
+  if (!sawFinal) {
+    throw new JobEnvelopeError("Invalid job result: missing final chunk");
+  }
+  return bodySize;
 }
+async function openJobResult(sealedBytes, builderPrivateKey, ecies, expect) {
+  const bodySize = bufferedResultBodySize(sealedBytes);
+  const stream = new ReadableStream({
+    start(controller) {
+      controller.enqueue(sealedBytes);
+      controller.close();
+    }
+  });
+  const opened = await openJobResultStream(
+    stream,
+    builderPrivateKey,
+    ecies,
+    expect
+  );
+  const body = new Uint8Array(bodySize);
+  let offset = 0;
+  await opened.body.pipeTo(
+    new WritableStream({
+      write(chunk) {
+        body.set(chunk, offset);
+        offset += chunk.length;
+      }
+    })
+  );
+  if (offset !== body.length) {
+    throw new JobEnvelopeError("Invalid job result: opened size mismatch");
+  }
+  return { ...opened.metadata, body };
+}
+
+// src/protocol/jobs-client.ts
+var import_errors3 = require("./errors.cjs");
 
 // src/protocol/write-signer.ts
+var import_errors2 = require("./errors.cjs");
 function isRecord(value) {
   return value !== null && typeof value === "object";
 }
@@ -33168,7 +33344,7 @@ function resolveWriteSigner(source, options = {}) {
   if (isViemWriteWalletClient(source)) {
     const account = options.account ?? source.account;
     if (account === void 0) {
-      throw new WriteRequestError(
+      throw new import_errors2.WriteRequestError(
         "Viem wallet client requires an account option or account property"
       );
     }
@@ -33184,7 +33360,7 @@ function resolveWriteSigner(source, options = {}) {
     };
   }
   if (!isRecord(source) || typeof source.signMessage !== "function") {
-    throw new WriteRequestError(
+    throw new import_errors2.WriteRequestError(
       "signer must be a viem LocalAccount, a viem WalletClient, or a { signMessage } object"
     );
   }
@@ -33225,7 +33401,7 @@ function normalizeGateway(gatewayUrl) {
   try {
     const url = new URL(gatewayUrl);
     if (url.pathname !== "/" || url.search !== "" || url.hash !== "") {
-      throw new JobRejectedError(
+      throw new import_errors3.JobRejectedError(
         "gatewayUrl must be an origin without a path, query, or fragment"
       );
     }
@@ -33234,8 +33410,8 @@ function normalizeGateway(gatewayUrl) {
       audience: url.origin
     };
   } catch (error) {
-    if (error instanceof JobRejectedError) throw error;
-    throw new JobRejectedError(
+    if (error instanceof import_errors3.JobRejectedError) throw error;
+    throw new import_errors3.JobRejectedError(
       "gatewayUrl must be an absolute URL",
       void 0,
       null,
@@ -33248,7 +33424,7 @@ function normalizeGateway(gatewayUrl) {
 function resolveFetch(fetchFn) {
   const resolved = fetchFn ?? globalThis.fetch;
   if (resolved === void 0) {
-    throw new JobRejectedError("No fetch implementation available");
+    throw new import_errors3.JobRejectedError("No fetch implementation available");
   }
   return resolved;
 }
@@ -33260,7 +33436,7 @@ function sourcePublicKey(source) {
 }
 function resolveBuilder(options) {
   if (options.builderPrivateKey && options.builderAccount) {
-    throw new JobRejectedError(
+    throw new import_errors3.JobRejectedError(
       "Provide builderPrivateKey or builderAccount, not both"
     );
   }
@@ -33268,12 +33444,12 @@ function resolveBuilder(options) {
   try {
     source = options.builderPrivateKey ? (0, import_accounts2.privateKeyToAccount)(options.builderPrivateKey) : options.builderAccount;
   } catch (error) {
-    throw new JobRejectedError("Invalid builder private key", void 0, null, {
+    throw new import_errors3.JobRejectedError("Invalid builder private key", void 0, null, {
       cause: error instanceof Error ? error.message : String(error)
     });
   }
   if (!source) {
-    throw new JobRejectedError(
+    throw new import_errors3.JobRejectedError(
       "builderPrivateKey or builderAccount is required"
     );
   }
@@ -33281,13 +33457,13 @@ function resolveBuilder(options) {
   try {
     signer = resolveWriteSigner(source);
   } catch (error) {
-    throw new JobRejectedError("Invalid builder signer", void 0, null, {
+    throw new import_errors3.JobRejectedError("Invalid builder signer", void 0, null, {
       cause: error instanceof Error ? error.message : String(error)
     });
   }
   const publicKey = sourcePublicKey(source);
   if (!signer.address || !publicKey) {
-    throw new JobRejectedError(
+    throw new import_errors3.JobRejectedError(
       "Builder signer must expose both address and publicKey"
     );
   }
@@ -33303,7 +33479,7 @@ function resolveBuilder(options) {
 function clampInteger(value, fallback, minimum, maximum, field) {
   const resolved = value ?? fallback;
   if (!Number.isFinite(resolved)) {
-    throw new JobRejectedError(`${field} must be a finite number`);
+    throw new import_errors3.JobRejectedError(`${field} must be a finite number`);
   }
   return Math.min(maximum, Math.max(minimum, Math.trunc(resolved)));
 }
@@ -33333,29 +33509,29 @@ async function rejectedResponse(response, fallback) {
   const message = response.status === HTTP_UNAUTHORIZED && parsed.reason ? `${parsed.message}: ${parsed.reason}` : parsed.message;
   if (response.status === HTTP_FORBIDDEN) {
     if (parsed.code === "BUILDER_UNKNOWN") {
-      return new BuilderUnknownError(parsed.message, details);
+      return new import_errors3.BuilderUnknownError(parsed.message, details);
     }
     if (parsed.code === "GRANT_INVALID") {
-      return new GrantInvalidError(parsed.message, details);
+      return new import_errors3.GrantInvalidError(parsed.message, details);
     }
     if (parsed.code === "OWNER_NOT_READY") {
-      return new OwnerNotReadyError(parsed.message, details);
+      return new import_errors3.OwnerNotReadyError(parsed.message, details);
     }
   }
   if (response.status === HTTP_NOT_FOUND) {
-    return new JobNotFoundError(parsed.message, details);
+    return new import_errors3.JobNotFoundError(parsed.message, details);
   }
   if (response.status === HTTP_CONFLICT && parsed.code === "JOB_ID_TAKEN") {
-    return new JobIdTakenError(parsed.message, details);
+    return new import_errors3.JobIdTakenError(parsed.message, details);
   }
   if (response.status === HTTP_PAYLOAD_TOO_LARGE) {
-    return new JobRequestTooLargeError(parsed.message, parsed.code, details);
+    return new import_errors3.JobRequestTooLargeError(parsed.message, parsed.code, details);
   }
-  return new JobRejectedError(message, response.status, parsed.code, details);
+  return new import_errors3.JobRejectedError(message, response.status, parsed.code, details);
 }
 function requireStatus(value, status) {
-  if (!isRecord2(value) || !isNonEmptyString(value["jobId"]) || typeof value["state"] !== "string" || !JOB_STATES.includes(value["state"]) || !isNonEmptyString(value["owner"]) || !isNonEmptyString(value["grantId"]) || !isNonEmptyString(value["scope"]) || !isNonEmptyString(value["operation"]) || !JOB_OPERATIONS.includes(value["operation"])) {
-    throw new JobRejectedError(
+  if (!isRecord2(value) || !isNonEmptyString(value["jobId"]) || typeof value["state"] !== "string" || !JOB_STATES.includes(value["state"]) || !isNonEmptyString(value["owner"]) || !isNonEmptyString(value["grantId"]) || !isNonEmptyString(value["scope"]) || !isNonEmptyString(value["operation"]) || !JOB_OPERATIONS.includes(value["operation"]) || value["state"] === "completed" && !isResultHandle(value["result"])) {
+    throw new import_errors3.JobRejectedError(
       "Gateway response did not contain a job status",
       status
     );
@@ -33365,6 +33541,17 @@ function requireStatus(value, status) {
 function isNonEmptyString(value) {
   return typeof value === "string" && value.length > 0;
 }
+function isResultHandle(value) {
+  if (!isRecord2(value) || !isNonEmptyString(value["objectKey"]) || !isNonEmptyString(value["url"]) || typeof value["size"] !== "number" || !Number.isInteger(value["size"]) || value["size"] < 0 || typeof value["hash"] !== "string" || !/^0x[0-9a-fA-F]{64}$/.test(value["hash"]) || typeof value["expiresAt"] !== "string" || Number.isNaN(Date.parse(value["expiresAt"]))) {
+    return false;
+  }
+  try {
+    const url = new URL(value["url"]);
+    return url.protocol === "https:" || url.protocol === "http:";
+  } catch {
+    return false;
+  }
+}
 function hasMatchingIdentityKey(value) {
   const address = value["address"];
   const publicKey = value["publicKey"];
@@ -33391,7 +33578,7 @@ function sleep2(ms) {
 }
 function requireFiniteDuration(value, field) {
   if (!Number.isFinite(value)) {
-    throw new JobRejectedError(`${field} must be a finite number`);
+    throw new import_errors3.JobRejectedError(`${field} must be a finite number`);
   }
   return Math.max(0, value);
 }
@@ -33405,7 +33592,7 @@ function createJobsClient(options) {
     try {
       return await fetchFn(url, init);
     } catch (error) {
-      throw new JobTransportError(
+      throw new import_errors3.JobTransportError(
         `${description} failed: ${error instanceof Error ? error.message : String(error)}`,
         error
       );
@@ -33426,19 +33613,19 @@ function createJobsClient(options) {
         await responseBody(response),
         "Owner identity not found"
       );
-      throw new OwnerNotReadyError(parsed.message, parsed.details);
+      throw new import_errors3.OwnerNotReadyError(parsed.message, parsed.details);
     }
     if (!response.ok) {
       throw await rejectedResponse(response, "Owner identity lookup rejected");
     }
     const body = await responseBody(response);
     if (!isRecord2(body) || body["state"] !== SEALED_IDENTITY_STATE || !isRecord2(body["identity"])) {
-      throw new OwnerNotReadyError("Owner identity is not sealed", {
+      throw new import_errors3.OwnerNotReadyError("Owner identity is not sealed", {
         state: isRecord2(body) ? body["state"] : void 0
       });
     }
     if (!hasExpectedIdentity(body["identity"], owner, options.chainId)) {
-      throw new JobRejectedError(
+      throw new import_errors3.JobRejectedError(
         "Gateway returned a malformed or mismatched owner identity",
         response.status
       );
@@ -33459,7 +33646,7 @@ function createJobsClient(options) {
       const jobId = (0, import_node_crypto.randomUUID)();
       const nowMs = now().getTime();
       if (!Number.isFinite(nowMs)) {
-        throw new JobRejectedError("now must return a valid Date");
+        throw new import_errors3.JobRejectedError("now must return a valid Date");
       }
       const deadline = new Date(
         nowMs + deadlineSeconds * MILLISECONDS_PER_SECOND
@@ -33527,7 +33714,7 @@ function createJobsClient(options) {
       if (response.status === HTTP_OK && isRecord2(body)) {
         const job = requireStatus(body["job"], response.status);
         if (job.jobId !== jobId) {
-          throw new JobRejectedError(
+          throw new import_errors3.JobRejectedError(
             "Gateway returned a job id that does not match the submission",
             response.status
           );
@@ -33537,7 +33724,7 @@ function createJobsClient(options) {
       if (response.status === HTTP_ACCEPTED && isRecord2(body) && body["jobId"] === jobId && typeof body["state"] === "string" && JOB_STATES.includes(body["state"])) {
         return { jobId, state: body["state"] };
       }
-      throw new JobRejectedError(
+      throw new import_errors3.JobRejectedError(
         "Gateway returned an undocumented job submission response",
         response.status
       );
@@ -33585,7 +33772,7 @@ function createJobsClient(options) {
       let latest;
       for (; ; ) {
         if (Date.now() >= callerDeadline) {
-          throw new JobTimeoutError(
+          throw new import_errors3.JobTimeoutError(
             `Timed out waiting for terminal job ${jobId}`,
             {
               jobId,
@@ -33598,7 +33785,7 @@ function createJobsClient(options) {
         if (TERMINAL_JOB_STATES.has(latest.state)) return latest;
         const remaining = callerDeadline - Date.now();
         if (remaining <= 0) {
-          throw new JobTimeoutError(
+          throw new import_errors3.JobTimeoutError(
             `Timed out waiting for terminal job ${jobId}`,
             {
               jobId,
@@ -33610,31 +33797,51 @@ function createJobsClient(options) {
         await sleep2(Math.min(pollMs, remaining));
       }
     },
-    async openResult(job, openOptions) {
-      if (!job.resultCiphertext) {
-        throw new JobRejectedError(
-          "Job status does not include inline resultCiphertext",
-          void 0,
-          null,
+    async openResult(handle, openOptions) {
+      if (!privateKey) {
+        throw new import_errors3.JobRejectedError(
+          "openResult requires createJobsClient({ builderPrivateKey })"
+        );
+      }
+      const response = await request(
+        handle.url,
+        { method: GET_METHOD },
+        "Job result fetch"
+      );
+      if (!response.ok) {
+        throw await rejectedResponse(response, "Job result fetch rejected");
+      }
+      let bytes;
+      try {
+        bytes = new Uint8Array(await response.arrayBuffer());
+      } catch (error) {
+        throw new import_errors3.JobTransportError(
+          `Job result fetch failed: ${error instanceof Error ? error.message : String(error)}`,
+          error
+        );
+      }
+      const actualHash = (0, import_viem16.bytesToHex)((0, import_sha26.sha256)(bytes));
+      if (actualHash.toLowerCase() !== handle.hash.toLowerCase()) {
+        throw new import_errors3.JobResultIntegrityError(
+          "Fetched job result hash does not match its handle",
           {
-            jobId: job.jobId,
-            state: job.state,
-            resultHandle: job.resultHandle,
-            maxInlineResultBytes: MAX_INLINE_RESULT_BYTES
+            objectKey: handle.objectKey,
+            expectedHash: handle.hash,
+            actualHash
           }
         );
       }
-      if (!privateKey) {
-        throw new JobRejectedError(
-          "openResult requires createJobsClient({ builderPrivateKey })"
+      if (bytes.length !== handle.size) {
+        throw new import_errors3.JobResultIntegrityError(
+          "Fetched job result size does not match its handle",
+          {
+            objectKey: handle.objectKey,
+            expectedSize: handle.size,
+            actualSize: bytes.length
+          }
         );
       }
-      return openJobResult(
-        job.resultCiphertext,
-        privateKey,
-        ecies,
-        openOptions.expect
-      );
+      return openJobResult(bytes, privateKey, ecies, openOptions.expect);
     },
     async readRaw(params) {
       const submitted = await client.submitRawRead(params);
@@ -33642,7 +33849,27 @@ function createJobsClient(options) {
         timeoutMs: params.timeoutMs,
         pollMs: params.pollMs
       });
-      return client.openResult(job, {
+      if (job.state !== "completed") {
+        throw new import_errors3.JobRejectedError(
+          `Job ${job.jobId} ended in state ${job.state}${job.failureReason ? `: ${job.failureReason}` : ""}`,
+          void 0,
+          null,
+          {
+            jobId: job.jobId,
+            state: job.state,
+            ...job.failureReason ? { failureReason: job.failureReason } : {}
+          }
+        );
+      }
+      if (!job.result) {
+        throw new import_errors3.JobRejectedError(
+          "Completed job status does not include a result handle",
+          void 0,
+          null,
+          { jobId: job.jobId, state: job.state }
+        );
+      }
+      return client.openResult(job.result, {
         expect: {
           jobId: submitted.jobId,
           scope: params.scope,
@@ -34348,10 +34575,12 @@ function buildMarkDataPointUnavailableRequest(config, input) {
 
 // src/protocol/data-point-deletion.ts
 var import_viem25 = require("viem");
+var import_errors5 = require("./errors.cjs");
 
 // src/protocol/lineage.ts
 var import_viem24 = require("viem");
 var import_zod = require("zod");
+var import_errors4 = require("./errors.cjs");
 
 // src/protocol/personal-server-error-body.ts
 function isRecord4(value) {
@@ -34423,7 +34652,7 @@ function derivedScopeViolatesNaming(derivedScope, sourceScope) {
 function assertDerivedScopeNaming(derivedScope, sourceScopes) {
   for (const sourceScope of sourceScopes) {
     if (derivedScopeViolatesNaming(derivedScope, sourceScope)) {
-      throw new WriteRequestError(
+      throw new import_errors4.WriteRequestError(
         `Derived scope ${derivedScope} must not share its first segment with source scope ${sourceScope}; put derivatives in the app's own namespace`,
         { scope: derivedScope, sourceScope }
       );
@@ -34486,7 +34715,7 @@ function normalizeBaseUrl(url) {
 function resolveFetch2(fetchFn) {
   const resolved = fetchFn ?? globalThis.fetch;
   if (resolved === void 0) {
-    throw new LineageReadError("No fetch implementation available");
+    throw new import_errors4.LineageReadError("No fetch implementation available");
   }
   return resolved;
 }
@@ -34494,7 +34723,7 @@ function normalizeVersion(version) {
   if (version === void 0) return void 0;
   const text = String(version);
   if (!VERSION_PATTERN.test(text)) {
-    throw new LineageReadError(
+    throw new import_errors4.LineageReadError(
       "version must be a positive decimal integer",
       void 0,
       "INVALID_VERSION",
@@ -34505,7 +34734,7 @@ function normalizeVersion(version) {
 }
 async function lineageReadFailure(source, response) {
   const { errorCode, message, details } = await readPersonalServerErrorBody(response);
-  return new LineageReadError(
+  return new import_errors4.LineageReadError(
     message ?? `${source} lineage read failed: ${response.status} ${response.statusText}`,
     response.status,
     errorCode,
@@ -34517,7 +34746,7 @@ async function parseLineageGraph(source, response) {
   try {
     body = await response.json();
   } catch (err) {
-    throw new LineageReadError(
+    throw new import_errors4.LineageReadError(
       `${source} lineage response is not JSON`,
       response.status,
       null,
@@ -34527,7 +34756,7 @@ async function parseLineageGraph(source, response) {
   const envelope = isRecord4(body) && isRecord4(body.data) ? body : void 0;
   const parsed = LineageGraphSchema.safeParse(envelope?.data ?? body);
   if (!parsed.success) {
-    throw new LineageReadError(
+    throw new import_errors4.LineageReadError(
       `${source} lineage response is not a lineage view`,
       response.status,
       null,
@@ -34542,7 +34771,7 @@ async function sendLineageRead(source, fetchFn, url, headers) {
   try {
     response = await fetchFn(url, { method: "GET", headers });
   } catch (err) {
-    throw new LineageReadError(
+    throw new import_errors4.LineageReadError(
       `${source} lineage read failed: ${err instanceof Error ? err.message : String(err)}`,
       void 0,
       null,
@@ -34583,7 +34812,7 @@ async function getPersonalServerLineage(params) {
 }
 async function getGatewayLineage(params) {
   if (!isDataPointId(params.dataPointId)) {
-    throw new LineageReadError(
+    throw new import_errors4.LineageReadError(
       "dataPointId must be a 32-byte hex string (see deriveDataPointId)",
       void 0,
       "INVALID_DATA_POINT_ID",
@@ -34729,13 +34958,13 @@ async function deleteDataPoint(input) {
   if (currentVersion === void 0) {
     const record = await input.gateway.getDataPoint(dataPointId);
     if (record === null) {
-      throw new DataPointNotFoundError(
+      throw new import_errors5.DataPointNotFoundError(
         `No data point registered for scope '${input.scope}' owned by ${ownerAddress}`,
         { dataPointId, scope: input.scope, ownerAddress }
       );
     }
     if (isDataPointTombstone(record)) {
-      throw new DataPointDeletedError(
+      throw new import_errors5.DataPointDeletedError(
         `Data point ${dataPointId} (scope '${input.scope}') is already deleted`,
         {
           dataPointId,
@@ -34781,6 +35010,9 @@ async function deleteDataPoint(input) {
   }
 }
 
+// src/protocol/personal-server-data.ts
+var import_errors6 = require("./errors.cjs");
+
 // src/protocol/data-file.ts
 var import_zod2 = require("zod");
 var DataFileEnvelopeSchema = import_zod2.z.object({
@@ -34839,7 +35071,7 @@ async function readPersonalServerData(params) {
   const request = await buildPersonalServerDataReadRequest(params);
   const response = await fetchFn(request);
   if (response.status === 410) {
-    throw new DataPointDeletedError(
+    throw new import_errors6.DataPointDeletedError(
       `Personal Server scope '${params.scope}' has been deleted`,
       {
         scope: params.scope,
@@ -34854,7 +35086,7 @@ async function readPersonalServerData(params) {
   }
   const body = await response.json();
   if (isDataPointTombstone(body)) {
-    throw new DataPointDeletedError(
+    throw new import_errors6.DataPointDeletedError(
       `Personal Server scope '${params.scope}' has been deleted`,
       { scope: params.scope, deletedAt: tombstoneDeletedAt(body) }
     );
@@ -35054,20 +35286,22 @@ function tryGrantPermissions(scopes) {
 }
 
 // src/protocol/personal-server-write.ts
-var import_sha27 = require("@noble/hashes/sha2");
+var import_sha28 = require("@noble/hashes/sha2");
 var import_viem27 = require("viem");
 var import_zod4 = require("zod");
+var import_errors8 = require("./errors.cjs");
 
 // src/protocol/write-request.ts
-var import_sha26 = require("@noble/hashes/sha2");
+var import_sha27 = require("@noble/hashes/sha2");
 var import_viem26 = require("viem");
+var import_errors7 = require("./errors.cjs");
 function normalizeBaseUrl2(url) {
   return url.replace(/\/+$/, "");
 }
 function resolveFetch3(fetchFn) {
   const resolved = fetchFn ?? globalThis.fetch;
   if (resolved === void 0) {
-    throw new WriteRequestError("No fetch implementation available");
+    throw new import_errors7.WriteRequestError("No fetch implementation available");
   }
   return resolved;
 }
@@ -35122,27 +35356,27 @@ function nextProofIat(proofKey) {
   return sleep3(waitSec * 1e3).then(() => iat);
 }
 function freshProofNonce() {
-  const webCrypto = globalThis.crypto;
-  if (typeof webCrypto?.randomUUID === "function") {
-    return webCrypto.randomUUID();
+  const webCrypto2 = globalThis.crypto;
+  if (typeof webCrypto2?.randomUUID === "function") {
+    return webCrypto2.randomUUID();
   }
-  if (typeof webCrypto?.getRandomValues === "function") {
-    return (0, import_viem26.bytesToHex)(webCrypto.getRandomValues(new Uint8Array(16)));
+  if (typeof webCrypto2?.getRandomValues === "function") {
+    return (0, import_viem26.bytesToHex)(webCrypto2.getRandomValues(new Uint8Array(16)));
   }
-  throw new WriteRequestError(
+  throw new import_errors7.WriteRequestError(
     "No secure random source available to build a proof nonce; provide a crypto global"
   );
 }
 function proofKeyFor(parts) {
   return (0, import_viem26.bytesToHex)(
-    (0, import_sha26.sha256)(
+    (0, import_sha27.sha256)(
       new TextEncoder().encode(
         JSON.stringify([
           parts.aud,
           parts.method,
           parts.uri,
           parts.grantId,
-          parts.signedBytes ? (0, import_viem26.bytesToHex)((0, import_sha26.sha256)(parts.signedBytes)) : ""
+          parts.signedBytes ? (0, import_viem26.bytesToHex)((0, import_sha27.sha256)(parts.signedBytes)) : ""
         ])
       )
     )
@@ -35164,7 +35398,7 @@ async function sendWithFreshProof(label, fetchFn, options, proofKey, build) {
       delayMs *= 2;
     }
   }
-  throw new WriteTransportError(
+  throw new import_errors7.WriteTransportError(
     `${label} failed after ${attempts} attempt(s): ${errorMessage(lastError)}`,
     attempts,
     lastError
@@ -35235,7 +35469,7 @@ async function openWriteSession(params) {
   const mintedAt = Date.now();
   if (!response.ok) {
     const { errorCode, message, details } = await readPersonalServerErrorBody(response);
-    throw new WriteSessionError(
+    throw new import_errors8.WriteSessionError(
       message ?? `Write session handshake failed: ${response.status} ${response.statusText}`,
       response.status,
       errorCode,
@@ -35246,7 +35480,7 @@ async function openWriteSession(params) {
   try {
     body = await response.json();
   } catch (err) {
-    throw new WriteSessionError(
+    throw new import_errors8.WriteSessionError(
       "Write session response is not JSON",
       response.status,
       null,
@@ -35255,7 +35489,7 @@ async function openWriteSession(params) {
   }
   const parsed = WriteSessionResponseSchema.safeParse(body);
   if (!parsed.success) {
-    throw new WriteSessionError(
+    throw new import_errors8.WriteSessionError(
       "Write session response is not a session",
       response.status,
       null,
@@ -35263,7 +35497,7 @@ async function openWriteSession(params) {
     );
   }
   if (parsed.data.token_type.toLowerCase() !== "bearer") {
-    throw new WriteSessionError(
+    throw new import_errors8.WriteSessionError(
       `Write session token type is not Bearer: ${parsed.data.token_type}`,
       response.status
     );
@@ -35285,7 +35519,7 @@ function isWriteSession(value) {
 }
 function sessionCoversScope(session, scope) {
   if (!isRecord4(session) || !Array.isArray(session.writeScopes) || !session.writeScopes.every((pattern) => typeof pattern === "string")) {
-    throw new WriteRequestError("session must come from openWriteSession");
+    throw new import_errors8.WriteRequestError("session must come from openWriteSession");
   }
   return session.writeScopes.some(
     (pattern) => scopeMatchesPattern(scope, pattern)
@@ -35310,12 +35544,12 @@ function encodeWriteMetadataHeader(metadata) {
   try {
     json = JSON.stringify(metadata);
   } catch (err) {
-    throw new WriteRequestError(
+    throw new import_errors8.WriteRequestError(
       `metadata is not JSON-serialisable: ${errorMessage(err)}`
     );
   }
   if (typeof json !== "string") {
-    throw new WriteRequestError("metadata must serialise to JSON");
+    throw new import_errors8.WriteRequestError("metadata must serialise to JSON");
   }
   return json.replace(
     /[\u007f-\uffff]/g,
@@ -35329,7 +35563,7 @@ function binaryWriteSignedBytes(input) {
     mimeType: normalizeBinaryMimeType(input.contentType),
     ...input.filename ? { filename: input.filename } : {},
     sizeBytes: input.bytes.length,
-    contentHash: (0, import_viem27.bytesToHex)((0, import_sha27.sha256)(input.bytes)),
+    contentHash: (0, import_viem27.bytesToHex)((0, import_sha28.sha256)(input.bytes)),
     encoding: "base64",
     content: toBase64(input.bytes),
     ...metadata !== void 0 ? { metadata } : {}
@@ -35350,7 +35584,7 @@ function setFilenameHeader(headers, filename) {
 function assertNoReservedKeys(value, where) {
   for (const key of RESERVED_WRITE_KEYS) {
     if (Object.prototype.hasOwnProperty.call(value, key)) {
-      throw new WriteRequestError(
+      throw new import_errors8.WriteRequestError(
         `${where} must not contain the reserved ${key} key; the Personal Server stamps it`,
         { key }
       );
@@ -35362,10 +35596,10 @@ function isLineagePair(value) {
 }
 function normalizeLineage(lineage, derivedScope) {
   if (!Array.isArray(lineage)) {
-    throw new WriteRequestError("lineage must be an array of data point ids");
+    throw new import_errors8.WriteRequestError("lineage must be an array of data point ids");
   }
   if (lineage.length > MAX_LINEAGE_SOURCES) {
-    throw new WriteRequestError(
+    throw new import_errors8.WriteRequestError(
       `lineage lists ${lineage.length} sources; the maximum is ${MAX_LINEAGE_SOURCES}`,
       { max: MAX_LINEAGE_SOURCES, count: lineage.length }
     );
@@ -35378,13 +35612,13 @@ function normalizeLineage(lineage, derivedScope) {
     let id;
     if (isLineagePair(entry)) {
       if (!(0, import_viem27.isAddress)(entry.ownerAddress, { strict: false })) {
-        throw new WriteRequestError(
+        throw new import_errors8.WriteRequestError(
           "lineage source ownerAddress must be an EVM address",
           { ownerAddress: entry.ownerAddress }
         );
       }
       if (entry.scope.length === 0) {
-        throw new WriteRequestError("lineage source scope is required");
+        throw new import_errors8.WriteRequestError("lineage source scope is required");
       }
       id = deriveDataPointId(entry.ownerAddress, entry.scope);
       sourceScopes.push(entry.scope);
@@ -35392,14 +35626,14 @@ function normalizeLineage(lineage, derivedScope) {
     } else if (isDataPointId(entry)) {
       id = entry;
     } else {
-      throw new WriteRequestError(
+      throw new import_errors8.WriteRequestError(
         "lineage entries must be 32-byte hex data point ids or { ownerAddress, scope } pairs",
         { entry }
       );
     }
     const normalized = id.toLowerCase();
     if (seen.has(normalized)) {
-      throw new WriteRequestError("lineage must not repeat a data point id", {
+      throw new import_errors8.WriteRequestError("lineage must not repeat a data point id", {
         dataPointId: normalized
       });
     }
@@ -35408,7 +35642,7 @@ function normalizeLineage(lineage, derivedScope) {
   }
   for (const own of ownIds) {
     if (seen.has(own)) {
-      throw new WriteRequestError(
+      throw new import_errors8.WriteRequestError(
         "lineage must not cite the record's own data point",
         { dataPointId: own, scope: derivedScope }
       );
@@ -35419,7 +35653,7 @@ function normalizeLineage(lineage, derivedScope) {
 }
 function assertNoLineageField(value, where) {
   if (Object.prototype.hasOwnProperty.call(value, LINEAGE_FIELD)) {
-    throw new WriteRequestError(
+    throw new import_errors8.WriteRequestError(
       `${where}.${LINEAGE_FIELD} is reserved; pass sources through the lineage option`
     );
   }
@@ -35427,7 +35661,7 @@ function assertNoLineageField(value, where) {
 function buildMetadataHeader(metadata, sources) {
   if (metadata !== void 0) {
     if (!isRecord4(metadata)) {
-      throw new WriteRequestError("metadata must be a plain object");
+      throw new import_errors8.WriteRequestError("metadata must be a plain object");
     }
     assertNoReservedKeys(metadata, "metadata");
     assertNoLineageField(metadata, "metadata");
@@ -35440,24 +35674,24 @@ function buildMetadataHeader(metadata, sources) {
 }
 function prepareWrite(params) {
   if (params.binary !== void 0 && params.data !== void 0) {
-    throw new WriteRequestError("Pass either data or binary, not both");
+    throw new import_errors8.WriteRequestError("Pass either data or binary, not both");
   }
   const rawLineage = params.lineage;
   const sources = rawLineage === void 0 || rawLineage === null ? void 0 : normalizeLineage(rawLineage, params.scope);
   if (params.binary !== void 0) {
     const { bytes, contentType, filename } = params.binary;
     if (!(bytes instanceof Uint8Array)) {
-      throw new WriteRequestError("binary.bytes must be a Uint8Array");
+      throw new import_errors8.WriteRequestError("binary.bytes must be a Uint8Array");
     }
     if (typeof contentType !== "string" || contentType.trim() === "") {
-      throw new WriteRequestError("binary.contentType is required");
+      throw new import_errors8.WriteRequestError("binary.contentType is required");
     }
     if (filename !== void 0) {
       if (typeof filename !== "string") {
-        throw new WriteRequestError("binary.filename must be a string");
+        throw new import_errors8.WriteRequestError("binary.filename must be a string");
       }
       if (filename !== filename.trim()) {
-        throw new WriteRequestError(
+        throw new import_errors8.WriteRequestError(
           "binary.filename must not have leading or trailing whitespace"
         );
       }
@@ -35477,13 +35711,13 @@ function prepareWrite(params) {
     };
   }
   if (params.data === void 0) {
-    throw new WriteRequestError("Pass data (a JSON object) or binary");
+    throw new import_errors8.WriteRequestError("Pass data (a JSON object) or binary");
   }
   if (!isRecord4(params.data)) {
-    throw new WriteRequestError("data must be a plain JSON object");
+    throw new import_errors8.WriteRequestError("data must be a plain JSON object");
   }
   if (params.metadata !== void 0) {
-    throw new WriteRequestError(
+    throw new import_errors8.WriteRequestError(
       "metadata applies to binary writes; put fields to store inside data"
     );
   }
@@ -35494,12 +35728,12 @@ function prepareWrite(params) {
   try {
     text = JSON.stringify(record);
   } catch (err) {
-    throw new WriteRequestError(
+    throw new import_errors8.WriteRequestError(
       `data is not JSON-serialisable: ${errorMessage(err)}`
     );
   }
   if (typeof text !== "string" || !text.startsWith("{")) {
-    throw new WriteRequestError("data must serialise to a JSON object");
+    throw new import_errors8.WriteRequestError("data must serialise to a JSON object");
   }
   const body = new TextEncoder().encode(text);
   return {
@@ -35512,31 +35746,31 @@ async function writeErrorFromResponse(response) {
   const { errorCode, message, details } = await readPersonalServerErrorBody(response);
   const text = message ?? `Personal Server write failed: ${response.status} ${response.statusText}`;
   if (response.status === 422 || errorCode?.startsWith("LINEAGE_")) {
-    return new WriteLineageError(text, response.status, errorCode, details);
+    return new import_errors8.WriteLineageError(text, response.status, errorCode, details);
   }
   switch (response.status) {
     case 401:
-      return new WriteUnauthorizedError(text, errorCode, details);
+      return new import_errors8.WriteUnauthorizedError(text, errorCode, details);
     case 403:
-      return new WriteForbiddenError(text, errorCode, details);
+      return new import_errors8.WriteForbiddenError(text, errorCode, details);
     case 409:
-      return new WriteConflictError(text, errorCode, details);
+      return new import_errors8.WriteConflictError(text, errorCode, details);
     default:
-      return new WriteRejectedError(text, response.status, errorCode, details);
+      return new import_errors8.WriteRejectedError(text, response.status, errorCode, details);
   }
 }
 async function writeData(params) {
   const { session } = params;
   if (!isWriteSession(session)) {
-    throw new WriteRequestError("session must come from openWriteSession");
+    throw new import_errors8.WriteRequestError("session must come from openWriteSession");
   }
   const fetchFn = resolveFetch3(params.fetch);
   if (typeof params.scope !== "string" || params.scope.length === 0) {
-    throw new WriteRequestError("scope is required");
+    throw new import_errors8.WriteRequestError("scope is required");
   }
   const prepared = prepareWrite(params);
   if (Date.now() >= session.expiresAt) {
-    throw new WriteSessionExpiredError(
+    throw new import_errors8.WriteSessionExpiredError(
       "Write session has expired; open a new session",
       { grantId: session.grantId, expiresAt: session.expiresAt }
     );
@@ -35592,7 +35826,7 @@ async function writeData(params) {
   try {
     body = await response.json();
   } catch (err) {
-    throw new WriteRejectedError(
+    throw new import_errors8.WriteRejectedError(
       "Personal Server write response is not JSON",
       response.status,
       null,
@@ -35601,7 +35835,7 @@ async function writeData(params) {
   }
   const parsed = WriteDataResultSchema.safeParse(body);
   if (!parsed.success) {
-    throw new WriteRejectedError(
+    throw new import_errors8.WriteRejectedError(
       "Personal Server write response is not an ingest result",
       response.status,
       null,
@@ -35628,6 +35862,7 @@ async function writePersonalServerData(params) {
 
 // src/protocol/derivative-questions.ts
 var import_zod5 = require("zod");
+var import_errors9 = require("./errors.cjs");
 var DERIVATIVE_QUESTIONS_PATH = "/v1/derivatives/questions";
 var MAX_QUESTION_SOURCE_SCOPES = 16;
 var MAX_QUESTION_CHARS = 8e3;
@@ -35710,15 +35945,15 @@ function fetchIdOf(fetchFn) {
 }
 function resolveRequest(params) {
   if (typeof params.personalServerUrl !== "string" || params.personalServerUrl.length === 0) {
-    throw new WriteRequestError("personalServerUrl is required");
+    throw new import_errors9.WriteRequestError("personalServerUrl is required");
   }
   if (typeof params.grantId !== "string" || params.grantId.length === 0) {
-    throw new WriteRequestError(
+    throw new import_errors9.WriteRequestError(
       "grantId is required; a question call runs under the grant carrying write:<derivedScope>"
     );
   }
   if (params.signer === null || typeof params.signer !== "object") {
-    throw new WriteRequestError(
+    throw new import_errors9.WriteRequestError(
       "signer must be a viem LocalAccount, a viem WalletClient, or a { signMessage } object"
     );
   }
@@ -35772,37 +36007,37 @@ async function questionErrorFromResponse(response, body) {
   const text = message ?? `Derivative question request failed: ${response.status} ${response.statusText}`;
   switch (errorCode) {
     case "DERIVATIVE_SOURCE_NOT_GRANTED":
-      return new DerivativeSourceNotGrantedError(text, errorCode, details);
+      return new import_errors9.DerivativeSourceNotGrantedError(text, errorCode, details);
     case "DERIVATIVE_CYCLE":
-      return new DerivativeCycleError(text, errorCode, details);
+      return new import_errors9.DerivativeCycleError(text, errorCode, details);
     case "DERIVATIVE_COMPUTE_UNAVAILABLE":
-      return new DerivativeComputeUnavailableError(text, errorCode, details);
+      return new import_errors9.DerivativeComputeUnavailableError(text, errorCode, details);
     case "DERIVATIVE_QUESTION_INVALID":
     case "LINEAGE_SCOPE_UNDER_SOURCE_PREFIX":
-      return new DerivativeQuestionInvalidError(
+      return new import_errors9.DerivativeQuestionInvalidError(
         text,
         response.status,
         errorCode,
         details
       );
     case "DERIVATIVE_QUESTION_NOT_FOUND":
-      return new DerivativeQuestionNotFoundError(text, errorCode, details);
+      return new import_errors9.DerivativeQuestionNotFoundError(text, errorCode, details);
     case "DERIVATIVE_DERIVED_SCOPE_REQUIRED":
-      return new DerivativeDerivedScopeRequiredError(text, errorCode, details);
+      return new import_errors9.DerivativeDerivedScopeRequiredError(text, errorCode, details);
     default:
       break;
   }
   switch (response.status) {
     case 401:
-      return new WriteUnauthorizedError(text, errorCode, details);
+      return new import_errors9.WriteUnauthorizedError(text, errorCode, details);
     case 403:
-      return new WriteForbiddenError(text, errorCode, details);
+      return new import_errors9.WriteForbiddenError(text, errorCode, details);
     case 404:
-      return new DerivativeQuestionNotFoundError(text, errorCode, details);
+      return new import_errors9.DerivativeQuestionNotFoundError(text, errorCode, details);
     case 409:
-      return new WriteConflictError(text, errorCode, details);
+      return new import_errors9.WriteConflictError(text, errorCode, details);
     default:
-      return new DerivativeQuestionRejectedError(
+      return new import_errors9.DerivativeQuestionRejectedError(
         text,
         response.status,
         errorCode,
@@ -35882,7 +36117,7 @@ async function sendQuestionRequest(params, spec, schema) {
   try {
     body = await response.json();
   } catch (err) {
-    throw new DerivativeQuestionRejectedError(
+    throw new import_errors9.DerivativeQuestionRejectedError(
       `${spec.label} response is not JSON`,
       response.status,
       null,
@@ -35891,7 +36126,7 @@ async function sendQuestionRequest(params, spec, schema) {
   }
   const parsed = schema.safeParse(body);
   if (!parsed.success) {
-    throw new DerivativeQuestionRejectedError(
+    throw new import_errors9.DerivativeQuestionRejectedError(
       `${spec.label} response is not a derivative question answer`,
       response.status,
       null,
@@ -35902,22 +36137,22 @@ async function sendQuestionRequest(params, spec, schema) {
 }
 function assertQuestionId(questionId) {
   if (typeof questionId !== "string" || questionId.length === 0) {
-    throw new WriteRequestError("questionId is required");
+    throw new import_errors9.WriteRequestError("questionId is required");
   }
   return `${DERIVATIVE_QUESTIONS_PATH}/${encodeURIComponent(questionId)}`;
 }
 function registrationBody(params) {
   const { derivedScope, question } = params;
   if (typeof derivedScope !== "string" || derivedScope.length === 0) {
-    throw new WriteRequestError("derivedScope is required");
+    throw new import_errors9.WriteRequestError("derivedScope is required");
   }
   if (!Array.isArray(params.sourceScopes) || params.sourceScopes.length === 0) {
-    throw new WriteRequestError(
+    throw new import_errors9.WriteRequestError(
       "sourceScopes must be a non-empty array of scopes"
     );
   }
   if (params.sourceScopes.length > MAX_QUESTION_SOURCE_SCOPES) {
-    throw new WriteRequestError(
+    throw new import_errors9.WriteRequestError(
       `sourceScopes lists ${params.sourceScopes.length} scopes; the maximum is ${MAX_QUESTION_SOURCE_SCOPES}`,
       { max: MAX_QUESTION_SOURCE_SCOPES, count: params.sourceScopes.length }
     );
@@ -35925,15 +36160,15 @@ function registrationBody(params) {
   const sourceScopes = [];
   for (const scope of params.sourceScopes) {
     if (typeof scope !== "string" || scope.length === 0) {
-      throw new WriteRequestError("sourceScopes entries must be scope strings");
+      throw new import_errors9.WriteRequestError("sourceScopes entries must be scope strings");
     }
     if (sourceScopes.includes(scope)) {
-      throw new WriteRequestError("sourceScopes must not repeat a scope", {
+      throw new import_errors9.WriteRequestError("sourceScopes must not repeat a scope", {
         duplicate: scope
       });
     }
     if (scope === derivedScope) {
-      throw new WriteRequestError(
+      throw new import_errors9.WriteRequestError(
         "derivedScope cannot be one of its own sources",
         { scope }
       );
@@ -35941,17 +36176,17 @@ function registrationBody(params) {
     sourceScopes.push(scope);
   }
   if (typeof question !== "string" || question.trim() === "") {
-    throw new WriteRequestError("question must be a non-empty string");
+    throw new import_errors9.WriteRequestError("question must be a non-empty string");
   }
   if (question.length > MAX_QUESTION_CHARS) {
-    throw new WriteRequestError(
+    throw new import_errors9.WriteRequestError(
       `question is ${question.length} characters; the maximum is ${MAX_QUESTION_CHARS}`,
       { max: MAX_QUESTION_CHARS, length: question.length }
     );
   }
   if (params.model !== void 0) {
     if (typeof params.model !== "string" || params.model.length > MAX_QUESTION_MODEL_CHARS || !MODEL_ID_PATTERN.test(params.model)) {
-      throw new WriteRequestError("model must be a provider model id", {
+      throw new import_errors9.WriteRequestError("model must be a provider model id", {
         model: params.model
       });
     }
@@ -35987,7 +36222,7 @@ async function getQuestion(params) {
 }
 async function listQuestions(params) {
   if (typeof params.derivedScope !== "string" || params.derivedScope.length === 0) {
-    throw new WriteRequestError(
+    throw new import_errors9.WriteRequestError(
       "derivedScope is required; a builder may only list its own questions on a scope it may write"
     );
   }
@@ -36045,7 +36280,7 @@ async function waitForQuestion(params) {
     if (isSettled(latest.status)) return latest;
     const remaining = deadline - Date.now();
     if (remaining <= 0) {
-      throw new DerivativeQuestionTimeoutError(
+      throw new import_errors9.DerivativeQuestionTimeoutError(
         `Derivative question ${latest.questionId} was still ${latest.status} after ${timeoutMs}ms`,
         {
           questionId: latest.questionId,
@@ -36065,7 +36300,7 @@ async function askPersonalServer(params) {
     questionId: registered.questionId
   });
   if (registration.status !== "ready") {
-    throw new DerivativeQuestionFailedError(
+    throw new import_errors9.DerivativeQuestionFailedError(
       `Derivative question ${registration.questionId} failed: ${registration.error ?? "no reason given"}`,
       {
         questionId: registration.questionId,
@@ -36092,6 +36327,7 @@ async function askPersonalServer(params) {
 
 // src/protocol/derivative-status.ts
 var import_zod6 = require("zod");
+var import_errors10 = require("./errors.cjs");
 var DERIVATIVE_STATUS_PATH = "/v1/derivatives/status";
 var DEFAULT_DERIVATIVE_STATUS_TIMEOUT_MS = 12e4;
 var DEFAULT_DERIVATIVE_STATUS_POLL_INTERVAL_MS = 2e3;
@@ -36122,13 +36358,13 @@ function normalizeBaseUrl3(url) {
 function resolveFetch4(fetchFn) {
   const resolved = fetchFn ?? globalThis.fetch;
   if (resolved === void 0) {
-    throw new WriteRequestError("No fetch implementation available");
+    throw new import_errors10.WriteRequestError("No fetch implementation available");
   }
   return resolved;
 }
 function requireDerivedScope(derivedScope) {
   if (typeof derivedScope !== "string" || derivedScope.length === 0) {
-    throw new WriteRequestError("derivedScope is required");
+    throw new import_errors10.WriteRequestError("derivedScope is required");
   }
   return derivedScope;
 }
@@ -36147,7 +36383,7 @@ function sleep4(ms, signal) {
   });
 }
 function timeoutError(latest, timeoutMs) {
-  return new DerivativeQuestionTimeoutError(
+  return new import_errors10.DerivativeQuestionTimeoutError(
     `Derived scope ${latest.derivedScope} was still ${latest.status} after ${timeoutMs}ms`,
     {
       derivedScope: latest.derivedScope,
@@ -36160,7 +36396,7 @@ function timeoutError(latest, timeoutMs) {
 }
 function abortError2(signal) {
   const reason = signal?.reason;
-  return reason instanceof Error ? reason : new WriteRequestError("Derivative status wait was aborted");
+  return reason instanceof Error ? reason : new import_errors10.WriteRequestError("Derivative status wait was aborted");
 }
 function isDerivativeStatusSettled(status) {
   if (status.status === "ready") return true;
@@ -36193,7 +36429,7 @@ async function getDerivativeStatus(params) {
       }
     );
   } catch (err) {
-    throw new WriteTransportError(
+    throw new import_errors10.WriteTransportError(
       `Derivative status read failed: ${err instanceof Error ? err.message : String(err)}`,
       1,
       err
@@ -36208,7 +36444,7 @@ async function getDerivativeStatus(params) {
   try {
     body = await response.json();
   } catch (err) {
-    throw new DerivativeQuestionRejectedError(
+    throw new import_errors10.DerivativeQuestionRejectedError(
       "Derivative status response is not JSON",
       response.status,
       null,
@@ -36217,7 +36453,7 @@ async function getDerivativeStatus(params) {
   }
   const parsed = DerivativeStatusSchema.safeParse(body);
   if (!parsed.success) {
-    throw new DerivativeQuestionRejectedError(
+    throw new import_errors10.DerivativeQuestionRejectedError(
       "Derivative status response is not a status view",
       response.status,
       null,
@@ -36251,6 +36487,7 @@ async function waitForDerivativeStatus(params) {
 }
 
 // src/protocol/gateway.ts
+var import_errors11 = require("./errors.cjs");
 function withGrantPermissions(grant) {
   const stripped = { ...grant };
   delete stripped.permissions;
@@ -36296,7 +36533,7 @@ function createGatewayClient(baseUrl) {
   }
   async function deletedError(res, details) {
     const body = await readBody(res);
-    return new DataPointDeletedError(
+    return new import_errors11.DataPointDeletedError(
       `Data point ${details.dataPointId ?? details.scope ?? ""} has been deleted`,
       { ...details, deletedAt: tombstoneDeletedAt(body) }
     );
@@ -36369,7 +36606,7 @@ function createGatewayClient(baseUrl) {
       }
       const record = await unwrapEnvelope(res);
       if (!options?.includeDeleted && isDataPointTombstone(record)) {
-        throw new DataPointDeletedError(
+        throw new import_errors11.DataPointDeletedError(
           `Data point ${dataPointId} has been deleted`,
           {
             dataPointId,
@@ -36531,7 +36768,7 @@ function createGatewayClient(baseUrl) {
         })
       });
       if (res.status === 404) {
-        throw new DataPointNotFoundError(
+        throw new import_errors11.DataPointNotFoundError(
           `Data point ${dataPointId} (scope '${params.scope}') is not registered`,
           details
         );
@@ -36542,7 +36779,7 @@ function createGatewayClient(baseUrl) {
           body2["currentExpectedVersion"]
         );
         const detail = stringOrUndefined(body2["error"]) ?? res.statusText;
-        throw new DataPointVersionConflictError(
+        throw new import_errors11.DataPointVersionConflictError(
           `Gateway error: 409 ${detail}`,
           {
             ...details,
@@ -36673,6 +36910,7 @@ function createGatewayClient(baseUrl) {
 }
 
 // src/protocol/escrow.ts
+var import_viem28 = require("viem");
 var GENERIC_PAYMENT_TYPES = {
   GenericPayment: [
     { name: "payerAddress", type: "address" },
@@ -36712,6 +36950,26 @@ var ESCROW_DEPOSIT_ABI2 = [
   }
 ];
 var NATIVE_ASSET_ADDRESS = "0x0000000000000000000000000000000000000000";
+var EscrowWithdrawalLifecycleError = class extends Error {
+  constructor(httpStatus, result) {
+    super(result.error);
+    this.httpStatus = httpStatus;
+    this.result = result;
+  }
+  httpStatus;
+  result;
+  name = "EscrowWithdrawalLifecycleError";
+};
+var EscrowWithdrawalRejectionError = class extends Error {
+  constructor(httpStatus, result) {
+    super(result.error);
+    this.httpStatus = httpStatus;
+    this.result = result;
+  }
+  httpStatus;
+  result;
+  name = "EscrowWithdrawalRejectionError";
+};
 function createEscrowGatewayClient(baseUrl) {
   const base = baseUrl.replace(/\/+$/, "");
   async function throwOnError(res, context) {
@@ -36727,6 +36985,27 @@ function createEscrowGatewayClient(baseUrl) {
       );
     }
   }
+  async function throwOnWithdrawError(res) {
+    if (res.ok) return;
+    let body;
+    try {
+      body = await res.json();
+    } catch {
+      throw new Error(
+        `Escrow gateway error (POST /v1/escrow/withdraw): ${res.status} ${res.statusText}`
+      );
+    }
+    if (isEscrowWithdrawalFailureResult(body)) {
+      throw new EscrowWithdrawalLifecycleError(res.status, body);
+    }
+    if (isEscrowWithdrawalRejectedResult(body)) {
+      throw new EscrowWithdrawalRejectionError(res.status, body);
+    }
+    const error = getGatewayErrorMessage(body);
+    throw new Error(
+      `Escrow gateway error (POST /v1/escrow/withdraw): ${res.status} ${res.statusText}${error ? `: ${error}` : ""}`
+    );
+  }
   return {
     async submitDeposit({ txHash }) {
       const res = await fetch(`${base}/v1/escrow/deposit`, {
@@ -36782,9 +37061,108 @@ function createEscrowGatewayClient(baseUrl) {
       });
       await throwOnError(res, "POST /v1/escrow/pay");
       return res.json();
+    },
+    async withdraw({
+      account,
+      asset,
+      amount,
+      withdrawNonce,
+      deadline,
+      signature
+    }) {
+      const res = await fetch(`${base}/v1/escrow/withdraw`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Web3Signed ${signature}`
+        },
+        body: JSON.stringify({
+          account,
+          asset,
+          amount,
+          withdrawNonce,
+          deadline
+        })
+      });
+      await throwOnWithdrawError(res);
+      return res.json();
+    },
+    async getWithdrawNonce(account) {
+      const res = await fetch(
+        `${base}/v1/escrow/withdraw/nonce?account=${encodeURIComponent(account)}`,
+        { cache: "no-store" }
+      );
+      await throwOnError(res, "GET /v1/escrow/withdraw/nonce");
+      const body = await res.json();
+      if (!isWithdrawNonceResponse(body, account)) {
+        throw new Error(
+          "GET /v1/escrow/withdraw/nonce: invalid response structure"
+        );
+      }
+      return body;
     }
   };
 }
+function getGatewayErrorMessage(body) {
+  if (typeof body === "object" && body !== null && "error" in body && typeof body.error === "string") {
+    return body.error;
+  }
+  return void 0;
+}
+function isEscrowWithdrawalFailureResult(body) {
+  if (typeof body !== "object" || body === null) return false;
+  const value = body;
+  return value.success === false && (value.status === "retryable" || value.status === "reorged" || value.status === "failed") && typeof value.error === "string" && isAddressHex(value.account) && isAddressHex(value.asset) && isUint256Decimal(value.amount) && isUint256Decimal(value.withdrawNonce) && isUint256Decimal(value.deadline) && (isHash(value.txHash) || value.txHash === null) && (!("blockNumber" in value) || isBlockNumber(value.blockNumber));
+}
+function isEscrowWithdrawalRejectedResult(body) {
+  if (typeof body !== "object" || body === null) return false;
+  const value = body;
+  return value.success === false && value.status === "rejected" && isWithdrawalRejectionCode(value.code) && typeof value.error === "string" && isAddressHex(value.account) && isAddressHex(value.asset) && isUint256Decimal(value.amount) && isUint256Decimal(value.withdrawNonce) && isUint256Decimal(value.deadline) && optionalUint256Decimal(value.balance) && optionalUint256Decimal(value.authorizedAmount) && optionalUint256Decimal(value.withdrawingAmount) && optionalUint256Decimal(value.availableAmount) && optionalUint256Decimal(value.requestedAmount) && optionalUint256Decimal(value.minimumAmount);
+}
+function isWithdrawalRejectionCode(value) {
+  return value === "below_minimum" || value === "deadline_too_far" || value === "expired" || value === "insufficient_available" || value === "stale_nonce";
+}
+function optionalUint256Decimal(value) {
+  return value === void 0 || isUint256Decimal(value);
+}
+function isAddressHex(value) {
+  return typeof value === "string" && (0, import_viem28.isHex)(value, { strict: true }) && value.length === 42;
+}
+function isHash(value) {
+  return typeof value === "string" && (0, import_viem28.isHex)(value, { strict: true }) && value.length === 66;
+}
+function isUint256Decimal(value) {
+  if (typeof value !== "string" || value.length === 0 || value.length > 78) {
+    return false;
+  }
+  if (!/^(0|[1-9]\d*)$/.test(value)) return false;
+  return BigInt(value) <= 2n ** 256n - 1n;
+}
+function isBlockNumber(value) {
+  return value === null || isUint256Decimal(value);
+}
+function isWithdrawNonceResponse(body, requestedAccount) {
+  if (typeof body !== "object" || body === null) return false;
+  const value = body;
+  if (value.success !== true) return false;
+  if (!isAddressHex(value.account)) return false;
+  if (value.account.toLowerCase() !== requestedAccount.toLowerCase())
+    return false;
+  if (typeof value.chainId !== "string") return false;
+  if (!/^(0|[1-9]\d*)$/.test(value.chainId)) return false;
+  const isLastNull = value.lastWithdrawNonce === null;
+  const lastNonceValid = isLastNull || isUint256Decimal(value.lastWithdrawNonce);
+  if (!lastNonceValid) return false;
+  if (!isUint256Decimal(value.nextWithdrawNonce)) return false;
+  if (isLastNull) {
+    return value.nextWithdrawNonce === "1";
+  }
+  const lastNonce = BigInt(value.lastWithdrawNonce);
+  const nextNonce = BigInt(value.nextWithdrawNonce);
+  const expectedNextNonce = lastNonce + 1n;
+  if (expectedNextNonce > 2n ** 256n - 1n) return false;
+  return nextNonce === expectedNextNonce;
+}
 
 // src/direct/escrow-payment.ts
 var GRANT_OP_TYPE = "grant";
@@ -36821,12 +37199,12 @@ var UINT256_MAX = (1n << 256n) - 1n;
 var ADDRESS_RE = /^0x[0-9a-fA-F]{40}$/;
 var BYTES32_RE = /^0x[0-9a-fA-F]{64}$/;
 var SIGNATURE_RE = /^0x[0-9a-fA-F]{130}$/;
-function isUint256Decimal(value, allowZero) {
+function isUint256Decimal2(value, allowZero) {
   const pattern = allowZero ? /^(0|[1-9]\d*)$/ : /^[1-9]\d*$/;
   return value.length <= UINT256_MAX.toString().length && pattern.test(value) && BigInt(value) <= UINT256_MAX;
 }
 function isValidAccessRecord(record) {
-  return BYTES32_RE.test(record.dataPointId) && isUint256Decimal(record.version, false) && ADDRESS_RE.test(record.accessor) && BYTES32_RE.test(record.recordId) && SIGNATURE_RE.test(record.signature);
+  return BYTES32_RE.test(record.dataPointId) && isUint256Decimal2(record.version, false) && ADDRESS_RE.test(record.accessor) && BYTES32_RE.test(record.recordId) && SIGNATURE_RE.test(record.signature);
 }
 function validateSigningOperation(payerAddress, required) {
   if (!ADDRESS_RE.test(payerAddress)) {
@@ -36838,10 +37216,10 @@ function validateSigningOperation(payerAddress, required) {
   if (!ADDRESS_RE.test(required.asset || NATIVE_ASSET_ADDRESS)) {
     throw new Error("Payment asset must be a 20-byte EVM address");
   }
-  if (!isUint256Decimal(required.amount, true)) {
+  if (!isUint256Decimal2(required.amount, true)) {
     throw new Error("Payment amount must be a canonical uint256 decimal");
   }
-  if (required.paymentNonce !== void 0 && !isUint256Decimal(required.paymentNonce, false)) {
+  if (required.paymentNonce !== void 0 && !isUint256Decimal2(required.paymentNonce, false)) {
     throw new Error("Payment nonce must be a positive uint256 decimal");
   }
   const accessRecord = required.accessRecord;
@@ -36972,7 +37350,7 @@ function paymentResponseMetadataFromHeader(header) {
     const registrationFee = stringField(breakdown, "registrationFee");
     const dataAccessFee = stringField(breakdown, "dataAccessFee");
     const paidAt = stringField(result, "paidAt");
-    if (result?.success !== true || !opType || !opId || !BYTES32_RE.test(opId) || !payerAddress || !ADDRESS_RE.test(payerAddress) || !asset || !ADDRESS_RE.test(asset) || !amount || !isUint256Decimal(amount, true) || !paymentNonce || !isUint256Decimal(paymentNonce, false) || !registrationFee || !isUint256Decimal(registrationFee, true) || !dataAccessFee || !isUint256Decimal(dataAccessFee, true) || typeof breakdown?.registrationPaid !== "boolean" || !paidAt || !isCanonicalIsoTimestamp(paidAt)) {
+    if (result?.success !== true || !opType || !opId || !BYTES32_RE.test(opId) || !payerAddress || !ADDRESS_RE.test(payerAddress) || !asset || !ADDRESS_RE.test(asset) || !amount || !isUint256Decimal2(amount, true) || !paymentNonce || !isUint256Decimal2(paymentNonce, false) || !registrationFee || !isUint256Decimal2(registrationFee, true) || !dataAccessFee || !isUint256Decimal2(dataAccessFee, true) || typeof breakdown?.registrationPaid !== "boolean" || !paidAt || !isCanonicalIsoTimestamp(paidAt)) {
       return void 0;
     }
     return {
@@ -37021,18 +37399,9 @@ async function authorizeEscrowPayment(params) {
   return toDirectPaymentReceipt(result);
 }
 
-// src/direct/errors.ts
-var PersonalServerReadError = class extends VanaError {
-  constructor(message, status, details) {
-    super(message, "DIRECT_PERSONAL_SERVER_READ_ERROR");
-    this.status = status;
-    this.details = details;
-  }
-  status;
-  details;
-};
-
 // src/direct/personal-server-read.ts
+var import_errors12 = require("./direct/errors.cjs");
+var import_errors13 = require("./errors.cjs");
 function asRecord2(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
@@ -37062,21 +37431,21 @@ function isBytes32Hex(value) {
   return /^0x[0-9a-fA-F]{64}$/.test(value);
 }
 var UINT256_MAX2 = (1n << 256n) - 1n;
-function isAddressHex(value) {
+function isAddressHex2(value) {
   return /^0x[0-9a-fA-F]{40}$/.test(value);
 }
-function isUint256Decimal2(value, allowZero) {
+function isUint256Decimal3(value, allowZero) {
   const pattern = allowZero ? /^(0|[1-9]\d*)$/ : /^[1-9]\d*$/;
   return value.length <= UINT256_MAX2.toString().length && pattern.test(value) && BigInt(value) <= UINT256_MAX2;
 }
 function isValidDataAccessRecord(record) {
-  return isBytes32Hex(record.dataPointId) && isUint256Decimal2(record.version, false) && isAddressHex(record.accessor) && isBytes32Hex(record.recordId) && /^0x[0-9a-fA-F]{130}$/.test(record.signature);
+  return isBytes32Hex(record.dataPointId) && isUint256Decimal3(record.version, false) && isAddressHex2(record.accessor) && isBytes32Hex(record.recordId) && /^0x[0-9a-fA-F]{130}$/.test(record.signature);
 }
 function parseLegacyGrantOperation(params) {
   const { challengeGrantId, challengeOpId, challengeOpType, grantId } = params;
   const opType = challengeOpType ?? GRANT_OP_TYPE;
   if (opType !== GRANT_OP_TYPE) {
-    throw new PersonalServerReadError(
+    throw new import_errors12.PersonalServerReadError(
       "Personal Server payment challenge used an unsupported escrow op type",
       402,
       { opType: challengeOpType }
@@ -37084,14 +37453,14 @@ function parseLegacyGrantOperation(params) {
   }
   const opId = challengeOpId ?? challengeGrantId ?? grantId;
   if (!opId || !isBytes32Hex(opId)) {
-    throw new PersonalServerReadError(
+    throw new import_errors12.PersonalServerReadError(
       "Personal Server payment challenge used an invalid escrow op id",
       402,
       { opId }
     );
   }
   if (opId.toLowerCase() !== grantId.toLowerCase()) {
-    throw new PersonalServerReadError(
+    throw new import_errors12.PersonalServerReadError(
       "Personal Server payment challenge did not match the requested grant",
       402,
       { opId, grantId }
@@ -37121,7 +37490,7 @@ function parseCanonicalDataAccessAccept(value) {
   const accessRecord = parseAccessRecord(accept?.accessRecord);
   const acceptAsset = stringField2(accept, "asset");
   const acceptAmount = stringField2(accept, "amount");
-  if (!network || !payerAddress || !isAddressHex(payerAddress) || !opId || !isBytes32Hex(opId) || !asset || !isAddressHex(asset) || !amount || !isUint256Decimal2(amount, true) || !paymentNonce || !isUint256Decimal2(paymentNonce, false) || !accessRecord || !isValidDataAccessRecord(accessRecord) || payerAddress.toLowerCase() !== accessRecord.accessor.toLowerCase() || opId.toLowerCase() !== accessRecord.recordId.toLowerCase() || !acceptAsset || acceptAsset.toLowerCase() !== asset.toLowerCase() || acceptAmount !== amount) {
+  if (!network || !payerAddress || !isAddressHex2(payerAddress) || !opId || !isBytes32Hex(opId) || !asset || !isAddressHex2(asset) || !amount || !isUint256Decimal3(amount, true) || !paymentNonce || !isUint256Decimal3(paymentNonce, false) || !accessRecord || !isValidDataAccessRecord(accessRecord) || payerAddress.toLowerCase() !== accessRecord.accessor.toLowerCase() || opId.toLowerCase() !== accessRecord.recordId.toLowerCase() || !acceptAsset || acceptAsset.toLowerCase() !== asset.toLowerCase() || acceptAmount !== amount) {
     return null;
   }
   return {
@@ -37137,7 +37506,7 @@ function parseCanonicalDataAccessAccept(value) {
 function parseCanonicalDataAccessPayment(params) {
   const { body, grantId, raw } = params;
   if (body.x402Version !== 1 || body.error !== "PAYMENT_REQUIRED") {
-    throw new PersonalServerReadError(
+    throw new import_errors12.PersonalServerReadError(
       "Personal Server data-access payment response was not a canonical x402 challenge",
       402
     );
@@ -37176,20 +37545,20 @@ async function parsePersonalServerPaymentRequired(res, grantId) {
     "accepts"
   );
   if (hasAcceptsEnvelope && (body.x402Version !== 1 || body.error !== "PAYMENT_REQUIRED")) {
-    throw new PersonalServerReadError(
+    throw new import_errors12.PersonalServerReadError(
       "Personal Server grant payment response was not a canonical x402 challenge",
       402
     );
   }
   const accept = preferredLegacyAccept(body);
   if (hasDataAccessMarker(body) && !accept) {
-    throw new PersonalServerReadError(
+    throw new import_errors12.PersonalServerReadError(
       "Personal Server data-access payment challenge was untrusted or incomplete",
       402
     );
   }
   if (hasAcceptsEnvelope && !accept) {
-    throw new PersonalServerReadError(
+    throw new import_errors12.PersonalServerReadError(
       "Personal Server grant payment challenge had no compatible escrow offer",
       402
     );
@@ -37206,8 +37575,8 @@ async function parsePersonalServerPaymentRequired(res, grantId) {
     const acceptAmount = stringField2(accept, "amount");
     const accessRecord2 = parseAccessRecord(accept.accessRecord);
     const hasAccessRecord = accept.accessRecord !== void 0;
-    if (!network || !payerAddress || !isAddressHex(payerAddress) || !opId || !isBytes32Hex(opId) || !asset || !isAddressHex(asset) || !amount || !isUint256Decimal2(amount, true) || !paymentNonce || !isUint256Decimal2(paymentNonce, false) || !acceptAsset || acceptAsset.toLowerCase() !== asset.toLowerCase() || acceptAmount !== amount || hasAccessRecord && (!accessRecord2 || !isValidDataAccessRecord(accessRecord2) || accessRecord2.accessor.toLowerCase() !== payerAddress.toLowerCase()) || amount === "0" && !accessRecord2) {
-      throw new PersonalServerReadError(
+    if (!network || !payerAddress || !isAddressHex2(payerAddress) || !opId || !isBytes32Hex(opId) || !asset || !isAddressHex2(asset) || !amount || !isUint256Decimal3(amount, true) || !paymentNonce || !isUint256Decimal3(paymentNonce, false) || !acceptAsset || acceptAsset.toLowerCase() !== asset.toLowerCase() || acceptAmount !== amount || hasAccessRecord && (!accessRecord2 || !isValidDataAccessRecord(accessRecord2) || accessRecord2.accessor.toLowerCase() !== payerAddress.toLowerCase()) || amount === "0" && !accessRecord2) {
+      throw new import_errors12.PersonalServerReadError(
         "Personal Server grant payment challenge was untrusted or incomplete",
         402
       );
@@ -37323,14 +37692,11 @@ async function parsePSError(response) {
   AccountPersonalServerLiteOwnerBindingError,
   AccountPersonalServerRegistrationError,
   BUILDER_REGISTRATION_TYPES,
-  BlockchainError,
   BrowserPlatformAdapter,
-  BuilderUnknownError,
   CLAIM_POLL_FLOOR_MS,
   CONTRACTS,
   CallbackStorage,
   ContractFactory,
-  ContractNotFoundError,
   DATA_ACCESS_OP_TYPE,
   DATA_REGISTRY_STATUS_ABI,
   DEFAULT_DERIVATIVE_STATUS_POLL_INTERVAL_MS,
@@ -37343,21 +37709,9 @@ async function parsePSError(response) {
   DERIVATIVE_QUESTIONS_PATH,
   DERIVATIVE_STATUS_PATH,
   DataFileEnvelopeSchema,
-  DataPointDeletedError,
-  DataPointNotFoundError,
   DataPointStatus,
-  DataPointVersionConflictError,
-  DerivativeComputeUnavailableError,
-  DerivativeCycleError,
-  DerivativeDerivedScopeRequiredError,
   DerivativeErrorCodeSchema,
-  DerivativeQuestionFailedError,
-  DerivativeQuestionInvalidError,
-  DerivativeQuestionNotFoundError,
-  DerivativeQuestionRejectedError,
   DerivativeQuestionSchema,
-  DerivativeQuestionTimeoutError,
-  DerivativeSourceNotGrantedError,
   DerivativeStatusSchema,
   DropboxStorage,
   ECIESError,
@@ -37365,6 +37719,8 @@ async function parsePSError(response) {
   ENCLAVE_TRUST_ANCHORS,
   ENCLAVE_WALLET_PURPOSE,
   ESCROW_DEPOSIT_ABI,
+  EscrowWithdrawalLifecycleError,
+  EscrowWithdrawalRejectionError,
   ExpiredTokenError,
   FEE_REGISTRY_ABI,
   GENERIC_PAYMENT_TYPES,
@@ -37372,35 +37728,26 @@ async function parsePSError(response) {
   GRANT_REGISTRATION_TYPES,
   GRANT_REVOCATION_TYPES,
   GoogleDriveStorage,
-  GrantInvalidError,
   InMemoryTokenStore,
   IngestResponseSchema,
-  InvalidConfigurationError,
   InvalidScopeEntryError,
   InvalidSignatureError,
   IpfsStorage,
   JOB_OPERATIONS,
   JOB_PROTOCOL_VERSION,
+  JOB_RESULT_CHUNK_BYTES,
+  JOB_RESULT_FORMAT_VERSION,
   JOB_STATES,
   JobEnvelopeError,
-  JobIdTakenError,
-  JobNotFoundError,
-  JobRejectedError,
-  JobRequestTooLargeError,
-  JobTimeoutError,
-  JobTransportError,
-  JobsClientError,
   LINEAGE_FIELD,
   LINEAGE_KEY,
   LineageEntrySchema,
   LineageGraphSchema,
   LineageNodeSchema,
-  LineageReadError,
   MASTER_KEY_MESSAGE,
   MASTER_SIGNATURE_DELIVERY_MAX_AGE_SECONDS,
   MASTER_SIGNATURE_DELIVERY_VERSION,
   MAX_ATTEMPTS,
-  MAX_INLINE_RESULT_BYTES,
   MAX_JOB_DEADLINE_SECONDS,
   MAX_LEASE_SECONDS,
   MAX_LINEAGE_SOURCES,
@@ -37411,12 +37758,9 @@ async function parsePSError(response) {
   MissingAuthError,
   NATIVE_ASSET_ADDRESS,
   NATIVE_VANA_ASSET,
-  NetworkError,
   NodeECIESProvider,
   NodePlatformAdapter,
-  NonceError,
   OAuthClient,
-  OwnerNotReadyError,
   PERSONAL_SERVER_LITE_OWNER_BINDING_PREFIX,
   PERSONAL_SERVER_LITE_OWNER_BINDING_PURPOSE,
   PERSONAL_SERVER_LITE_OWNER_BINDING_VERSION,
@@ -37425,9 +37769,6 @@ async function parsePSError(response) {
   PKCE_CHALLENGE_PATTERN,
   PKCE_VERIFIER_PATTERN,
   PSError,
-  PermissionError,
-  PersonalServerError,
-  PersonalServerWriteError,
   PinataStorage,
   QUESTION_STATUSES,
   QuestionDeleteResultSchema,
@@ -37438,42 +37779,26 @@ async function parsePSError(response) {
   RECORD_DATA_ACCESS_TYPES,
   REGISTRATION_KIND_FOR_OP,
   RESERVED_WRITE_KEYS,
-  ReadOnlyError,
   RedactedLineageNodeSchema,
-  RelayerError,
   SCOPE_ACTIONS,
   SEALED_ENVELOPE_VERSION,
   SERVER_REGISTRATION_TYPES,
   ScopeSchema,
-  SerializationError,
-  ServerUrlMismatchError,
-  SignatureError,
   StorageError,
   StorageManager,
   TOMBSTONE_DATA_HASH,
   TOMBSTONE_DATA_HASH_PREIMAGE,
   TOMBSTONE_METADATA_HASH,
   TOMBSTONE_METADATA_HASH_PREIMAGE,
-  TransactionPendingError,
   USER_PS_ID_DOMAIN,
-  UserRejectedRequestError,
-  VanaError,
   VanaStorage,
+  WITHDRAW_AUTHORIZATION_TYPES,
   WRITER_ATTRIBUTION_KEY,
   WRITE_CONTENT_DISPOSITION_HEADER,
   WRITE_FILENAME_HEADER,
   WRITE_METADATA_HEADER,
   WRITE_SESSION_PATH,
   WRITE_SIGNATURE_HEADER,
-  WriteConflictError,
-  WriteForbiddenError,
-  WriteLineageError,
-  WriteRejectedError,
-  WriteRequestError,
-  WriteSessionError,
-  WriteSessionExpiredError,
-  WriteTransportError,
-  WriteUnauthorizedError,
   appRootPreimage,
   askPersonalServer,
   assertDerivedScopeNaming,
@@ -37496,6 +37821,7 @@ async function parsePSError(response) {
   buildPersonalServerRegistrationTypedData,
   buildSetDataPointStatusRequest,
   buildWeb3SignedHeader,
+  buildWithdrawAuthorizationTypedData,
   builderRegistrationDomain,
   canonicalJobRequestBytes,
   chains,
@@ -37578,6 +37904,7 @@ async function parsePSError(response) {
   normalizeBinaryMimeType,
   openJobRequest,
   openJobResult,
+  openJobResultStream,
   openWriteSession,
   parsePSError,
   parsePersonalServerPaymentRequired,
@@ -37603,6 +37930,7 @@ async function parsePSError(response) {
   scopeToPathSegments,
   sealJobRequest,
   sealJobResult,
+  sealJobResultStream,
   serializeECIES,
   serverRegistrationDomain,
   sessionCoversScope,
@@ -37621,7 +37949,9 @@ async function parsePSError(response) {
   verifyWeb3Signed,
   waitForDerivativeStatus,
   waitForQuestion,
+  withdrawAuthorizationDomain,
   writeData,
-  writePersonalServerData
+  writePersonalServerData,
+  ...require("./errors.cjs")
 });
 //# sourceMappingURL=index.node.cjs.map