Source file traces.ml

[@@@ocaml.warning "-27-30-39-44"]

type key_kind =
  | Keykind_unspecified 
  | Keykind_user_form 
  | Keykind_user_bundle 
  | Keykind_user_asset 
  | Keykind_checksum_valuesfile 
  | Keykind_package_dist 

type standard_module_id = {
  vendor : string option;
  qualifier : string option;
  unit_ : string option;
  namespace_front : string list;
  namespace_tail : string option;
}

type semver = {
  major : int64 option;
  minor : int64 option;
  patch : int64 option;
  prerelease : string list;
  build : string list;
}

type module_version = {
  module_id : standard_module_id option;
  module_semver : semver option;
}

type package_id = {
  vendor : string option;
  qualifier : string option;
  unit_ : string option;
  namespace : string list;
}

type package_version = {
  package_id : package_id option;
  package_semver : semver option;
}

type position = {
  line : int32 option;
  byte_bol : int32 option;
  byte_col : int32 option;
  correction : int32 option;
}

type range = {
  start : position option;
  end_ : position option;
}

type key = {
  keykind : key_kind option;
  debug_reference_file_sha256 : string option;
  checksum_sha256 : string option;
  values_canonical_id : string option;
  module_version : module_version option;
  package_version : package_version option;
  keykind_slot : string list;
  keykind_assetpath : string option;
  debug_reference_range : range option;
}

type dependency = {
  depkey : key option;
  kvhash : string option;
}

type value_type =
  | Valuetype_unspecified 
  | Valuetype_form 
  | Valuetype_object 
  | Valuetype_constant 
  | Valuetype_bundle 
  | Valuetype_asset 
  | Valuetype_valuesfile 
  | Valuetype_values 
  | Valuetype_distribution 

type checksum = {
  checksum_value : string option;
  checksum_range : range option;
}

type value = {
  valuetype : value_type option;
  value_id : string option;
  value_sha256 : string option;
  valuesfile_canonical_id : string option;
  values_canonical_id : string option;
  values_file_sha256 : string option;
  values_file_local : string option;
  form_values_file_sha256 : string option;
  form_id : module_version option;
  form_values_canonical_id : string option;
  object_id : module_version option;
  object_range : range option;
  bundle_values_file_sha256 : string option;
  bundle_id : module_version option;
  bundle_range : range option;
  bundle_values_canonical_id : string option;
  bundle_values_file_local : string option;
  asset_values_file_sha256 : string option;
  asset_id : module_version option;
  asset_path : string option;
  asset_range : range option;
  asset_values_canonical_id : string option;
  asset_mirrors : string list;
  asset_checksum_sha256 : checksum option;
  asset_checksum_sha1 : checksum option;
  dist_id : package_version option;
  dist_json : string option;
}

type constructive_trace = {
  key : key option;
  dependencies : dependency list;
  value : value option;
}

let rec default_key_kind () = (Keykind_unspecified:key_kind)

let rec default_standard_module_id 
  ?vendor:((vendor:string option) = None)
  ?qualifier:((qualifier:string option) = None)
  ?unit_:((unit_:string option) = None)
  ?namespace_front:((namespace_front:string list) = [])
  ?namespace_tail:((namespace_tail:string option) = None)
  () : standard_module_id  = {
  vendor;
  qualifier;
  unit_;
  namespace_front;
  namespace_tail;
}

let rec default_semver 
  ?major:((major:int64 option) = None)
  ?minor:((minor:int64 option) = None)
  ?patch:((patch:int64 option) = None)
  ?prerelease:((prerelease:string list) = [])
  ?build:((build:string list) = [])
  () : semver  = {
  major;
  minor;
  patch;
  prerelease;
  build;
}

let rec default_module_version 
  ?module_id:((module_id:standard_module_id option) = None)
  ?module_semver:((module_semver:semver option) = None)
  () : module_version  = {
  module_id;
  module_semver;
}

let rec default_package_id 
  ?vendor:((vendor:string option) = None)
  ?qualifier:((qualifier:string option) = None)
  ?unit_:((unit_:string option) = None)
  ?namespace:((namespace:string list) = [])
  () : package_id  = {
  vendor;
  qualifier;
  unit_;
  namespace;
}

let rec default_package_version 
  ?package_id:((package_id:package_id option) = None)
  ?package_semver:((package_semver:semver option) = None)
  () : package_version  = {
  package_id;
  package_semver;
}

let rec default_position 
  ?line:((line:int32 option) = None)
  ?byte_bol:((byte_bol:int32 option) = None)
  ?byte_col:((byte_col:int32 option) = None)
  ?correction:((correction:int32 option) = None)
  () : position  = {
  line;
  byte_bol;
  byte_col;
  correction;
}

let rec default_range 
  ?start:((start:position option) = None)
  ?end_:((end_:position option) = None)
  () : range  = {
  start;
  end_;
}

let rec default_key 
  ?keykind:((keykind:key_kind option) = None)
  ?debug_reference_file_sha256:((debug_reference_file_sha256:string option) = None)
  ?checksum_sha256:((checksum_sha256:string option) = None)
  ?values_canonical_id:((values_canonical_id:string option) = None)
  ?module_version:((module_version:module_version option) = None)
  ?package_version:((package_version:package_version option) = None)
  ?keykind_slot:((keykind_slot:string list) = [])
  ?keykind_assetpath:((keykind_assetpath:string option) = None)
  ?debug_reference_range:((debug_reference_range:range option) = None)
  () : key  = {
  keykind;
  debug_reference_file_sha256;
  checksum_sha256;
  values_canonical_id;
  module_version;
  package_version;
  keykind_slot;
  keykind_assetpath;
  debug_reference_range;
}

let rec default_dependency 
  ?depkey:((depkey:key option) = None)
  ?kvhash:((kvhash:string option) = None)
  () : dependency  = {
  depkey;
  kvhash;
}

let rec default_value_type () = (Valuetype_unspecified:value_type)

let rec default_checksum 
  ?checksum_value:((checksum_value:string option) = None)
  ?checksum_range:((checksum_range:range option) = None)
  () : checksum  = {
  checksum_value;
  checksum_range;
}

let rec default_value 
  ?valuetype:((valuetype:value_type option) = None)
  ?value_id:((value_id:string option) = None)
  ?value_sha256:((value_sha256:string option) = None)
  ?valuesfile_canonical_id:((valuesfile_canonical_id:string option) = None)
  ?values_canonical_id:((values_canonical_id:string option) = None)
  ?values_file_sha256:((values_file_sha256:string option) = None)
  ?values_file_local:((values_file_local:string option) = None)
  ?form_values_file_sha256:((form_values_file_sha256:string option) = None)
  ?form_id:((form_id:module_version option) = None)
  ?form_values_canonical_id:((form_values_canonical_id:string option) = None)
  ?object_id:((object_id:module_version option) = None)
  ?object_range:((object_range:range option) = None)
  ?bundle_values_file_sha256:((bundle_values_file_sha256:string option) = None)
  ?bundle_id:((bundle_id:module_version option) = None)
  ?bundle_range:((bundle_range:range option) = None)
  ?bundle_values_canonical_id:((bundle_values_canonical_id:string option) = None)
  ?bundle_values_file_local:((bundle_values_file_local:string option) = None)
  ?asset_values_file_sha256:((asset_values_file_sha256:string option) = None)
  ?asset_id:((asset_id:module_version option) = None)
  ?asset_path:((asset_path:string option) = None)
  ?asset_range:((asset_range:range option) = None)
  ?asset_values_canonical_id:((asset_values_canonical_id:string option) = None)
  ?asset_mirrors:((asset_mirrors:string list) = [])
  ?asset_checksum_sha256:((asset_checksum_sha256:checksum option) = None)
  ?asset_checksum_sha1:((asset_checksum_sha1:checksum option) = None)
  ?dist_id:((dist_id:package_version option) = None)
  ?dist_json:((dist_json:string option) = None)
  () : value  = {
  valuetype;
  value_id;
  value_sha256;
  valuesfile_canonical_id;
  values_canonical_id;
  values_file_sha256;
  values_file_local;
  form_values_file_sha256;
  form_id;
  form_values_canonical_id;
  object_id;
  object_range;
  bundle_values_file_sha256;
  bundle_id;
  bundle_range;
  bundle_values_canonical_id;
  bundle_values_file_local;
  asset_values_file_sha256;
  asset_id;
  asset_path;
  asset_range;
  asset_values_canonical_id;
  asset_mirrors;
  asset_checksum_sha256;
  asset_checksum_sha1;
  dist_id;
  dist_json;
}

let rec default_constructive_trace 
  ?key:((key:key option) = None)
  ?dependencies:((dependencies:dependency list) = [])
  ?value:((value:value option) = None)
  () : constructive_trace  = {
  key;
  dependencies;
  value;
}

type standard_module_id_mutable = {
  mutable vendor : string option;
  mutable qualifier : string option;
  mutable unit_ : string option;
  mutable namespace_front : string list;
  mutable namespace_tail : string option;
}

let default_standard_module_id_mutable () : standard_module_id_mutable = {
  vendor = None;
  qualifier = None;
  unit_ = None;
  namespace_front = [];
  namespace_tail = None;
}

type semver_mutable = {
  mutable major : int64 option;
  mutable minor : int64 option;
  mutable patch : int64 option;
  mutable prerelease : string list;
  mutable build : string list;
}

let default_semver_mutable () : semver_mutable = {
  major = None;
  minor = None;
  patch = None;
  prerelease = [];
  build = [];
}

type module_version_mutable = {
  mutable module_id : standard_module_id option;
  mutable module_semver : semver option;
}

let default_module_version_mutable () : module_version_mutable = {
  module_id = None;
  module_semver = None;
}

type package_id_mutable = {
  mutable vendor : string option;
  mutable qualifier : string option;
  mutable unit_ : string option;
  mutable namespace : string list;
}

let default_package_id_mutable () : package_id_mutable = {
  vendor = None;
  qualifier = None;
  unit_ = None;
  namespace = [];
}

type package_version_mutable = {
  mutable package_id : package_id option;
  mutable package_semver : semver option;
}

let default_package_version_mutable () : package_version_mutable = {
  package_id = None;
  package_semver = None;
}

type position_mutable = {
  mutable line : int32 option;
  mutable byte_bol : int32 option;
  mutable byte_col : int32 option;
  mutable correction : int32 option;
}

let default_position_mutable () : position_mutable = {
  line = None;
  byte_bol = None;
  byte_col = None;
  correction = None;
}

type range_mutable = {
  mutable start : position option;
  mutable end_ : position option;
}

let default_range_mutable () : range_mutable = {
  start = None;
  end_ = None;
}

type key_mutable = {
  mutable keykind : key_kind option;
  mutable debug_reference_file_sha256 : string option;
  mutable checksum_sha256 : string option;
  mutable values_canonical_id : string option;
  mutable module_version : module_version option;
  mutable package_version : package_version option;
  mutable keykind_slot : string list;
  mutable keykind_assetpath : string option;
  mutable debug_reference_range : range option;
}

let default_key_mutable () : key_mutable = {
  keykind = None;
  debug_reference_file_sha256 = None;
  checksum_sha256 = None;
  values_canonical_id = None;
  module_version = None;
  package_version = None;
  keykind_slot = [];
  keykind_assetpath = None;
  debug_reference_range = None;
}

type dependency_mutable = {
  mutable depkey : key option;
  mutable kvhash : string option;
}

let default_dependency_mutable () : dependency_mutable = {
  depkey = None;
  kvhash = None;
}

type checksum_mutable = {
  mutable checksum_value : string option;
  mutable checksum_range : range option;
}

let default_checksum_mutable () : checksum_mutable = {
  checksum_value = None;
  checksum_range = None;
}

type value_mutable = {
  mutable valuetype : value_type option;
  mutable value_id : string option;
  mutable value_sha256 : string option;
  mutable valuesfile_canonical_id : string option;
  mutable values_canonical_id : string option;
  mutable values_file_sha256 : string option;
  mutable values_file_local : string option;
  mutable form_values_file_sha256 : string option;
  mutable form_id : module_version option;
  mutable form_values_canonical_id : string option;
  mutable object_id : module_version option;
  mutable object_range : range option;
  mutable bundle_values_file_sha256 : string option;
  mutable bundle_id : module_version option;
  mutable bundle_range : range option;
  mutable bundle_values_canonical_id : string option;
  mutable bundle_values_file_local : string option;
  mutable asset_values_file_sha256 : string option;
  mutable asset_id : module_version option;
  mutable asset_path : string option;
  mutable asset_range : range option;
  mutable asset_values_canonical_id : string option;
  mutable asset_mirrors : string list;
  mutable asset_checksum_sha256 : checksum option;
  mutable asset_checksum_sha1 : checksum option;
  mutable dist_id : package_version option;
  mutable dist_json : string option;
}

let default_value_mutable () : value_mutable = {
  valuetype = None;
  value_id = None;
  value_sha256 = None;
  valuesfile_canonical_id = None;
  values_canonical_id = None;
  values_file_sha256 = None;
  values_file_local = None;
  form_values_file_sha256 = None;
  form_id = None;
  form_values_canonical_id = None;
  object_id = None;
  object_range = None;
  bundle_values_file_sha256 = None;
  bundle_id = None;
  bundle_range = None;
  bundle_values_canonical_id = None;
  bundle_values_file_local = None;
  asset_values_file_sha256 = None;
  asset_id = None;
  asset_path = None;
  asset_range = None;
  asset_values_canonical_id = None;
  asset_mirrors = [];
  asset_checksum_sha256 = None;
  asset_checksum_sha1 = None;
  dist_id = None;
  dist_json = None;
}

type constructive_trace_mutable = {
  mutable key : key option;
  mutable dependencies : dependency list;
  mutable value : value option;
}

let default_constructive_trace_mutable () : constructive_trace_mutable = {
  key = None;
  dependencies = [];
  value = None;
}

[@@@ocaml.warning "-27-30-39"]

(** {2 Protobuf Encoding} *)

let rec encode_pb_key_kind (v:key_kind) encoder =
  match v with
  | Keykind_unspecified -> Pbrt.Encoder.int_as_varint (0) encoder
  | Keykind_user_form -> Pbrt.Encoder.int_as_varint 1 encoder
  | Keykind_user_bundle -> Pbrt.Encoder.int_as_varint 2 encoder
  | Keykind_user_asset -> Pbrt.Encoder.int_as_varint 3 encoder
  | Keykind_checksum_valuesfile -> Pbrt.Encoder.int_as_varint 7 encoder
  | Keykind_package_dist -> Pbrt.Encoder.int_as_varint 9 encoder

let rec encode_pb_standard_module_id (v:standard_module_id) encoder = 
  begin match v.vendor with
  | Some x -> 
    Pbrt.Encoder.string x encoder;
    Pbrt.Encoder.key 1 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.qualifier with
  | Some x -> 
    Pbrt.Encoder.string x encoder;
    Pbrt.Encoder.key 2 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.unit_ with
  | Some x -> 
    Pbrt.Encoder.string x encoder;
    Pbrt.Encoder.key 3 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  Pbrt.List_util.rev_iter_with (fun x encoder -> 
    Pbrt.Encoder.string x encoder;
    Pbrt.Encoder.key 4 Pbrt.Bytes encoder; 
  ) v.namespace_front encoder;
  begin match v.namespace_tail with
  | Some x -> 
    Pbrt.Encoder.string x encoder;
    Pbrt.Encoder.key 5 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  ()

let rec encode_pb_semver (v:semver) encoder = 
  begin match v.major with
  | Some x -> 
    Pbrt.Encoder.int64_as_varint x encoder;
    Pbrt.Encoder.key 1 Pbrt.Varint encoder; 
  | None -> ();
  end;
  begin match v.minor with
  | Some x -> 
    Pbrt.Encoder.int64_as_varint x encoder;
    Pbrt.Encoder.key 2 Pbrt.Varint encoder; 
  | None -> ();
  end;
  begin match v.patch with
  | Some x -> 
    Pbrt.Encoder.int64_as_varint x encoder;
    Pbrt.Encoder.key 3 Pbrt.Varint encoder; 
  | None -> ();
  end;
  Pbrt.List_util.rev_iter_with (fun x encoder -> 
    Pbrt.Encoder.string x encoder;
    Pbrt.Encoder.key 4 Pbrt.Bytes encoder; 
  ) v.prerelease encoder;
  Pbrt.List_util.rev_iter_with (fun x encoder -> 
    Pbrt.Encoder.string x encoder;
    Pbrt.Encoder.key 5 Pbrt.Bytes encoder; 
  ) v.build encoder;
  ()

let rec encode_pb_module_version (v:module_version) encoder = 
  begin match v.module_id with
  | Some x -> 
    Pbrt.Encoder.nested encode_pb_standard_module_id x encoder;
    Pbrt.Encoder.key 1 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.module_semver with
  | Some x -> 
    Pbrt.Encoder.nested encode_pb_semver x encoder;
    Pbrt.Encoder.key 2 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  ()

let rec encode_pb_package_id (v:package_id) encoder = 
  begin match v.vendor with
  | Some x -> 
    Pbrt.Encoder.string x encoder;
    Pbrt.Encoder.key 1 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.qualifier with
  | Some x -> 
    Pbrt.Encoder.string x encoder;
    Pbrt.Encoder.key 2 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.unit_ with
  | Some x -> 
    Pbrt.Encoder.string x encoder;
    Pbrt.Encoder.key 3 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  Pbrt.List_util.rev_iter_with (fun x encoder -> 
    Pbrt.Encoder.string x encoder;
    Pbrt.Encoder.key 4 Pbrt.Bytes encoder; 
  ) v.namespace encoder;
  ()

let rec encode_pb_package_version (v:package_version) encoder = 
  begin match v.package_id with
  | Some x -> 
    Pbrt.Encoder.nested encode_pb_package_id x encoder;
    Pbrt.Encoder.key 1 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.package_semver with
  | Some x -> 
    Pbrt.Encoder.nested encode_pb_semver x encoder;
    Pbrt.Encoder.key 2 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  ()

let rec encode_pb_position (v:position) encoder = 
  begin match v.line with
  | Some x -> 
    Pbrt.Encoder.int32_as_varint x encoder;
    Pbrt.Encoder.key 1 Pbrt.Varint encoder; 
  | None -> ();
  end;
  begin match v.byte_bol with
  | Some x -> 
    Pbrt.Encoder.int32_as_varint x encoder;
    Pbrt.Encoder.key 2 Pbrt.Varint encoder; 
  | None -> ();
  end;
  begin match v.byte_col with
  | Some x -> 
    Pbrt.Encoder.int32_as_varint x encoder;
    Pbrt.Encoder.key 3 Pbrt.Varint encoder; 
  | None -> ();
  end;
  begin match v.correction with
  | Some x -> 
    Pbrt.Encoder.int32_as_varint x encoder;
    Pbrt.Encoder.key 4 Pbrt.Varint encoder; 
  | None -> ();
  end;
  ()

let rec encode_pb_range (v:range) encoder = 
  begin match v.start with
  | Some x -> 
    Pbrt.Encoder.nested encode_pb_position x encoder;
    Pbrt.Encoder.key 1 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.end_ with
  | Some x -> 
    Pbrt.Encoder.nested encode_pb_position x encoder;
    Pbrt.Encoder.key 2 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  ()

let rec encode_pb_key (v:key) encoder = 
  begin match v.keykind with
  | Some x -> 
    encode_pb_key_kind x encoder;
    Pbrt.Encoder.key 1 Pbrt.Varint encoder; 
  | None -> ();
  end;
  begin match v.debug_reference_file_sha256 with
  | Some x -> 
    Pbrt.Encoder.string x encoder;
    Pbrt.Encoder.key 7 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.checksum_sha256 with
  | Some x -> 
    Pbrt.Encoder.string x encoder;
    Pbrt.Encoder.key 3 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.values_canonical_id with
  | Some x -> 
    Pbrt.Encoder.string x encoder;
    Pbrt.Encoder.key 8 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.module_version with
  | Some x -> 
    Pbrt.Encoder.nested encode_pb_module_version x encoder;
    Pbrt.Encoder.key 2 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.package_version with
  | Some x -> 
    Pbrt.Encoder.nested encode_pb_package_version x encoder;
    Pbrt.Encoder.key 9 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  Pbrt.List_util.rev_iter_with (fun x encoder -> 
    Pbrt.Encoder.string x encoder;
    Pbrt.Encoder.key 4 Pbrt.Bytes encoder; 
  ) v.keykind_slot encoder;
  begin match v.keykind_assetpath with
  | Some x -> 
    Pbrt.Encoder.string x encoder;
    Pbrt.Encoder.key 5 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.debug_reference_range with
  | Some x -> 
    Pbrt.Encoder.nested encode_pb_range x encoder;
    Pbrt.Encoder.key 6 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  ()

let rec encode_pb_dependency (v:dependency) encoder = 
  begin match v.depkey with
  | Some x -> 
    Pbrt.Encoder.nested encode_pb_key x encoder;
    Pbrt.Encoder.key 1 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.kvhash with
  | Some x -> 
    Pbrt.Encoder.string x encoder;
    Pbrt.Encoder.key 2 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  ()

let rec encode_pb_value_type (v:value_type) encoder =
  match v with
  | Valuetype_unspecified -> Pbrt.Encoder.int_as_varint (0) encoder
  | Valuetype_form -> Pbrt.Encoder.int_as_varint 1 encoder
  | Valuetype_object -> Pbrt.Encoder.int_as_varint 2 encoder
  | Valuetype_constant -> Pbrt.Encoder.int_as_varint 3 encoder
  | Valuetype_bundle -> Pbrt.Encoder.int_as_varint 4 encoder
  | Valuetype_asset -> Pbrt.Encoder.int_as_varint 5 encoder
  | Valuetype_valuesfile -> Pbrt.Encoder.int_as_varint 6 encoder
  | Valuetype_values -> Pbrt.Encoder.int_as_varint 7 encoder
  | Valuetype_distribution -> Pbrt.Encoder.int_as_varint 8 encoder

let rec encode_pb_checksum (v:checksum) encoder = 
  begin match v.checksum_value with
  | Some x -> 
    Pbrt.Encoder.string x encoder;
    Pbrt.Encoder.key 1 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.checksum_range with
  | Some x -> 
    Pbrt.Encoder.nested encode_pb_range x encoder;
    Pbrt.Encoder.key 2 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  ()

let rec encode_pb_value (v:value) encoder = 
  begin match v.valuetype with
  | Some x -> 
    encode_pb_value_type x encoder;
    Pbrt.Encoder.key 1 Pbrt.Varint encoder; 
  | None -> ();
  end;
  begin match v.value_id with
  | Some x -> 
    Pbrt.Encoder.string x encoder;
    Pbrt.Encoder.key 2 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.value_sha256 with
  | Some x -> 
    Pbrt.Encoder.string x encoder;
    Pbrt.Encoder.key 6 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.valuesfile_canonical_id with
  | Some x -> 
    Pbrt.Encoder.string x encoder;
    Pbrt.Encoder.key 21 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.values_canonical_id with
  | Some x -> 
    Pbrt.Encoder.string x encoder;
    Pbrt.Encoder.key 19 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.values_file_sha256 with
  | Some x -> 
    Pbrt.Encoder.string x encoder;
    Pbrt.Encoder.key 20 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.values_file_local with
  | Some x -> 
    Pbrt.Encoder.string x encoder;
    Pbrt.Encoder.key 27 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.form_values_file_sha256 with
  | Some x -> 
    Pbrt.Encoder.string x encoder;
    Pbrt.Encoder.key 3 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.form_id with
  | Some x -> 
    Pbrt.Encoder.nested encode_pb_module_version x encoder;
    Pbrt.Encoder.key 7 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.form_values_canonical_id with
  | Some x -> 
    Pbrt.Encoder.string x encoder;
    Pbrt.Encoder.key 15 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.object_id with
  | Some x -> 
    Pbrt.Encoder.nested encode_pb_module_version x encoder;
    Pbrt.Encoder.key 4 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.object_range with
  | Some x -> 
    Pbrt.Encoder.nested encode_pb_range x encoder;
    Pbrt.Encoder.key 5 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.bundle_values_file_sha256 with
  | Some x -> 
    Pbrt.Encoder.string x encoder;
    Pbrt.Encoder.key 8 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.bundle_id with
  | Some x -> 
    Pbrt.Encoder.nested encode_pb_module_version x encoder;
    Pbrt.Encoder.key 9 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.bundle_range with
  | Some x -> 
    Pbrt.Encoder.nested encode_pb_range x encoder;
    Pbrt.Encoder.key 10 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.bundle_values_canonical_id with
  | Some x -> 
    Pbrt.Encoder.string x encoder;
    Pbrt.Encoder.key 16 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.bundle_values_file_local with
  | Some x -> 
    Pbrt.Encoder.string x encoder;
    Pbrt.Encoder.key 22 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.asset_values_file_sha256 with
  | Some x -> 
    Pbrt.Encoder.string x encoder;
    Pbrt.Encoder.key 11 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.asset_id with
  | Some x -> 
    Pbrt.Encoder.nested encode_pb_module_version x encoder;
    Pbrt.Encoder.key 12 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.asset_path with
  | Some x -> 
    Pbrt.Encoder.string x encoder;
    Pbrt.Encoder.key 13 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.asset_range with
  | Some x -> 
    Pbrt.Encoder.nested encode_pb_range x encoder;
    Pbrt.Encoder.key 14 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.asset_values_canonical_id with
  | Some x -> 
    Pbrt.Encoder.string x encoder;
    Pbrt.Encoder.key 17 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  Pbrt.List_util.rev_iter_with (fun x encoder -> 
    Pbrt.Encoder.string x encoder;
    Pbrt.Encoder.key 18 Pbrt.Bytes encoder; 
  ) v.asset_mirrors encoder;
  begin match v.asset_checksum_sha256 with
  | Some x -> 
    Pbrt.Encoder.nested encode_pb_checksum x encoder;
    Pbrt.Encoder.key 23 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.asset_checksum_sha1 with
  | Some x -> 
    Pbrt.Encoder.nested encode_pb_checksum x encoder;
    Pbrt.Encoder.key 24 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.dist_id with
  | Some x -> 
    Pbrt.Encoder.nested encode_pb_package_version x encoder;
    Pbrt.Encoder.key 28 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  begin match v.dist_json with
  | Some x -> 
    Pbrt.Encoder.string x encoder;
    Pbrt.Encoder.key 29 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  ()

let rec encode_pb_constructive_trace (v:constructive_trace) encoder = 
  begin match v.key with
  | Some x -> 
    Pbrt.Encoder.nested encode_pb_key x encoder;
    Pbrt.Encoder.key 1 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  Pbrt.List_util.rev_iter_with (fun x encoder -> 
    Pbrt.Encoder.nested encode_pb_dependency x encoder;
    Pbrt.Encoder.key 2 Pbrt.Bytes encoder; 
  ) v.dependencies encoder;
  begin match v.value with
  | Some x -> 
    Pbrt.Encoder.nested encode_pb_value x encoder;
    Pbrt.Encoder.key 3 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  ()

[@@@ocaml.warning "-27-30-39"]

(** {2 Protobuf Decoding} *)

let rec decode_pb_key_kind d = 
  match Pbrt.Decoder.int_as_varint d with
  | 0 -> (Keykind_unspecified:key_kind)
  | 1 -> (Keykind_user_form:key_kind)
  | 2 -> (Keykind_user_bundle:key_kind)
  | 3 -> (Keykind_user_asset:key_kind)
  | 7 -> (Keykind_checksum_valuesfile:key_kind)
  | 9 -> (Keykind_package_dist:key_kind)
  | _ -> Pbrt.Decoder.malformed_variant "key_kind"

let rec decode_pb_standard_module_id d =
  let v = default_standard_module_id_mutable () in
  let continue__= ref true in
  while !continue__ do
    match Pbrt.Decoder.key d with
    | None -> (
      v.namespace_front <- List.rev v.namespace_front;
    ); continue__ := false
    | Some (1, Pbrt.Bytes) -> begin
      v.vendor <- Some (Pbrt.Decoder.string d);
    end
    | Some (1, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(standard_module_id), field(1)" pk
    | Some (2, Pbrt.Bytes) -> begin
      v.qualifier <- Some (Pbrt.Decoder.string d);
    end
    | Some (2, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(standard_module_id), field(2)" pk
    | Some (3, Pbrt.Bytes) -> begin
      v.unit_ <- Some (Pbrt.Decoder.string d);
    end
    | Some (3, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(standard_module_id), field(3)" pk
    | Some (4, Pbrt.Bytes) -> begin
      v.namespace_front <- (Pbrt.Decoder.string d) :: v.namespace_front;
    end
    | Some (4, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(standard_module_id), field(4)" pk
    | Some (5, Pbrt.Bytes) -> begin
      v.namespace_tail <- Some (Pbrt.Decoder.string d);
    end
    | Some (5, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(standard_module_id), field(5)" pk
    | Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind
  done;
  ({
    vendor = v.vendor;
    qualifier = v.qualifier;
    unit_ = v.unit_;
    namespace_front = v.namespace_front;
    namespace_tail = v.namespace_tail;
  } : standard_module_id)

let rec decode_pb_semver d =
  let v = default_semver_mutable () in
  let continue__= ref true in
  while !continue__ do
    match Pbrt.Decoder.key d with
    | None -> (
      v.build <- List.rev v.build;
      v.prerelease <- List.rev v.prerelease;
    ); continue__ := false
    | Some (1, Pbrt.Varint) -> begin
      v.major <- Some (Pbrt.Decoder.int64_as_varint d);
    end
    | Some (1, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(semver), field(1)" pk
    | Some (2, Pbrt.Varint) -> begin
      v.minor <- Some (Pbrt.Decoder.int64_as_varint d);
    end
    | Some (2, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(semver), field(2)" pk
    | Some (3, Pbrt.Varint) -> begin
      v.patch <- Some (Pbrt.Decoder.int64_as_varint d);
    end
    | Some (3, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(semver), field(3)" pk
    | Some (4, Pbrt.Bytes) -> begin
      v.prerelease <- (Pbrt.Decoder.string d) :: v.prerelease;
    end
    | Some (4, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(semver), field(4)" pk
    | Some (5, Pbrt.Bytes) -> begin
      v.build <- (Pbrt.Decoder.string d) :: v.build;
    end
    | Some (5, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(semver), field(5)" pk
    | Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind
  done;
  ({
    major = v.major;
    minor = v.minor;
    patch = v.patch;
    prerelease = v.prerelease;
    build = v.build;
  } : semver)

let rec decode_pb_module_version d =
  let v = default_module_version_mutable () in
  let continue__= ref true in
  while !continue__ do
    match Pbrt.Decoder.key d with
    | None -> (
    ); continue__ := false
    | Some (1, Pbrt.Bytes) -> begin
      v.module_id <- Some (decode_pb_standard_module_id (Pbrt.Decoder.nested d));
    end
    | Some (1, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(module_version), field(1)" pk
    | Some (2, Pbrt.Bytes) -> begin
      v.module_semver <- Some (decode_pb_semver (Pbrt.Decoder.nested d));
    end
    | Some (2, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(module_version), field(2)" pk
    | Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind
  done;
  ({
    module_id = v.module_id;
    module_semver = v.module_semver;
  } : module_version)

let rec decode_pb_package_id d =
  let v = default_package_id_mutable () in
  let continue__= ref true in
  while !continue__ do
    match Pbrt.Decoder.key d with
    | None -> (
      v.namespace <- List.rev v.namespace;
    ); continue__ := false
    | Some (1, Pbrt.Bytes) -> begin
      v.vendor <- Some (Pbrt.Decoder.string d);
    end
    | Some (1, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(package_id), field(1)" pk
    | Some (2, Pbrt.Bytes) -> begin
      v.qualifier <- Some (Pbrt.Decoder.string d);
    end
    | Some (2, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(package_id), field(2)" pk
    | Some (3, Pbrt.Bytes) -> begin
      v.unit_ <- Some (Pbrt.Decoder.string d);
    end
    | Some (3, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(package_id), field(3)" pk
    | Some (4, Pbrt.Bytes) -> begin
      v.namespace <- (Pbrt.Decoder.string d) :: v.namespace;
    end
    | Some (4, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(package_id), field(4)" pk
    | Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind
  done;
  ({
    vendor = v.vendor;
    qualifier = v.qualifier;
    unit_ = v.unit_;
    namespace = v.namespace;
  } : package_id)

let rec decode_pb_package_version d =
  let v = default_package_version_mutable () in
  let continue__= ref true in
  while !continue__ do
    match Pbrt.Decoder.key d with
    | None -> (
    ); continue__ := false
    | Some (1, Pbrt.Bytes) -> begin
      v.package_id <- Some (decode_pb_package_id (Pbrt.Decoder.nested d));
    end
    | Some (1, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(package_version), field(1)" pk
    | Some (2, Pbrt.Bytes) -> begin
      v.package_semver <- Some (decode_pb_semver (Pbrt.Decoder.nested d));
    end
    | Some (2, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(package_version), field(2)" pk
    | Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind
  done;
  ({
    package_id = v.package_id;
    package_semver = v.package_semver;
  } : package_version)

let rec decode_pb_position d =
  let v = default_position_mutable () in
  let continue__= ref true in
  while !continue__ do
    match Pbrt.Decoder.key d with
    | None -> (
    ); continue__ := false
    | Some (1, Pbrt.Varint) -> begin
      v.line <- Some (Pbrt.Decoder.int32_as_varint d);
    end
    | Some (1, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(position), field(1)" pk
    | Some (2, Pbrt.Varint) -> begin
      v.byte_bol <- Some (Pbrt.Decoder.int32_as_varint d);
    end
    | Some (2, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(position), field(2)" pk
    | Some (3, Pbrt.Varint) -> begin
      v.byte_col <- Some (Pbrt.Decoder.int32_as_varint d);
    end
    | Some (3, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(position), field(3)" pk
    | Some (4, Pbrt.Varint) -> begin
      v.correction <- Some (Pbrt.Decoder.int32_as_varint d);
    end
    | Some (4, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(position), field(4)" pk
    | Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind
  done;
  ({
    line = v.line;
    byte_bol = v.byte_bol;
    byte_col = v.byte_col;
    correction = v.correction;
  } : position)

let rec decode_pb_range d =
  let v = default_range_mutable () in
  let continue__= ref true in
  while !continue__ do
    match Pbrt.Decoder.key d with
    | None -> (
    ); continue__ := false
    | Some (1, Pbrt.Bytes) -> begin
      v.start <- Some (decode_pb_position (Pbrt.Decoder.nested d));
    end
    | Some (1, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(range), field(1)" pk
    | Some (2, Pbrt.Bytes) -> begin
      v.end_ <- Some (decode_pb_position (Pbrt.Decoder.nested d));
    end
    | Some (2, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(range), field(2)" pk
    | Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind
  done;
  ({
    start = v.start;
    end_ = v.end_;
  } : range)

let rec decode_pb_key d =
  let v = default_key_mutable () in
  let continue__= ref true in
  while !continue__ do
    match Pbrt.Decoder.key d with
    | None -> (
      v.keykind_slot <- List.rev v.keykind_slot;
    ); continue__ := false
    | Some (1, Pbrt.Varint) -> begin
      v.keykind <- Some (decode_pb_key_kind d);
    end
    | Some (1, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(key), field(1)" pk
    | Some (7, Pbrt.Bytes) -> begin
      v.debug_reference_file_sha256 <- Some (Pbrt.Decoder.string d);
    end
    | Some (7, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(key), field(7)" pk
    | Some (3, Pbrt.Bytes) -> begin
      v.checksum_sha256 <- Some (Pbrt.Decoder.string d);
    end
    | Some (3, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(key), field(3)" pk
    | Some (8, Pbrt.Bytes) -> begin
      v.values_canonical_id <- Some (Pbrt.Decoder.string d);
    end
    | Some (8, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(key), field(8)" pk
    | Some (2, Pbrt.Bytes) -> begin
      v.module_version <- Some (decode_pb_module_version (Pbrt.Decoder.nested d));
    end
    | Some (2, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(key), field(2)" pk
    | Some (9, Pbrt.Bytes) -> begin
      v.package_version <- Some (decode_pb_package_version (Pbrt.Decoder.nested d));
    end
    | Some (9, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(key), field(9)" pk
    | Some (4, Pbrt.Bytes) -> begin
      v.keykind_slot <- (Pbrt.Decoder.string d) :: v.keykind_slot;
    end
    | Some (4, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(key), field(4)" pk
    | Some (5, Pbrt.Bytes) -> begin
      v.keykind_assetpath <- Some (Pbrt.Decoder.string d);
    end
    | Some (5, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(key), field(5)" pk
    | Some (6, Pbrt.Bytes) -> begin
      v.debug_reference_range <- Some (decode_pb_range (Pbrt.Decoder.nested d));
    end
    | Some (6, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(key), field(6)" pk
    | Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind
  done;
  ({
    keykind = v.keykind;
    debug_reference_file_sha256 = v.debug_reference_file_sha256;
    checksum_sha256 = v.checksum_sha256;
    values_canonical_id = v.values_canonical_id;
    module_version = v.module_version;
    package_version = v.package_version;
    keykind_slot = v.keykind_slot;
    keykind_assetpath = v.keykind_assetpath;
    debug_reference_range = v.debug_reference_range;
  } : key)

let rec decode_pb_dependency d =
  let v = default_dependency_mutable () in
  let continue__= ref true in
  while !continue__ do
    match Pbrt.Decoder.key d with
    | None -> (
    ); continue__ := false
    | Some (1, Pbrt.Bytes) -> begin
      v.depkey <- Some (decode_pb_key (Pbrt.Decoder.nested d));
    end
    | Some (1, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(dependency), field(1)" pk
    | Some (2, Pbrt.Bytes) -> begin
      v.kvhash <- Some (Pbrt.Decoder.string d);
    end
    | Some (2, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(dependency), field(2)" pk
    | Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind
  done;
  ({
    depkey = v.depkey;
    kvhash = v.kvhash;
  } : dependency)

let rec decode_pb_value_type d = 
  match Pbrt.Decoder.int_as_varint d with
  | 0 -> (Valuetype_unspecified:value_type)
  | 1 -> (Valuetype_form:value_type)
  | 2 -> (Valuetype_object:value_type)
  | 3 -> (Valuetype_constant:value_type)
  | 4 -> (Valuetype_bundle:value_type)
  | 5 -> (Valuetype_asset:value_type)
  | 6 -> (Valuetype_valuesfile:value_type)
  | 7 -> (Valuetype_values:value_type)
  | 8 -> (Valuetype_distribution:value_type)
  | _ -> Pbrt.Decoder.malformed_variant "value_type"

let rec decode_pb_checksum d =
  let v = default_checksum_mutable () in
  let continue__= ref true in
  while !continue__ do
    match Pbrt.Decoder.key d with
    | None -> (
    ); continue__ := false
    | Some (1, Pbrt.Bytes) -> begin
      v.checksum_value <- Some (Pbrt.Decoder.string d);
    end
    | Some (1, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(checksum), field(1)" pk
    | Some (2, Pbrt.Bytes) -> begin
      v.checksum_range <- Some (decode_pb_range (Pbrt.Decoder.nested d));
    end
    | Some (2, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(checksum), field(2)" pk
    | Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind
  done;
  ({
    checksum_value = v.checksum_value;
    checksum_range = v.checksum_range;
  } : checksum)

let rec decode_pb_value d =
  let v = default_value_mutable () in
  let continue__= ref true in
  while !continue__ do
    match Pbrt.Decoder.key d with
    | None -> (
      v.asset_mirrors <- List.rev v.asset_mirrors;
    ); continue__ := false
    | Some (1, Pbrt.Varint) -> begin
      v.valuetype <- Some (decode_pb_value_type d);
    end
    | Some (1, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(value), field(1)" pk
    | Some (2, Pbrt.Bytes) -> begin
      v.value_id <- Some (Pbrt.Decoder.string d);
    end
    | Some (2, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(value), field(2)" pk
    | Some (6, Pbrt.Bytes) -> begin
      v.value_sha256 <- Some (Pbrt.Decoder.string d);
    end
    | Some (6, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(value), field(6)" pk
    | Some (21, Pbrt.Bytes) -> begin
      v.valuesfile_canonical_id <- Some (Pbrt.Decoder.string d);
    end
    | Some (21, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(value), field(21)" pk
    | Some (19, Pbrt.Bytes) -> begin
      v.values_canonical_id <- Some (Pbrt.Decoder.string d);
    end
    | Some (19, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(value), field(19)" pk
    | Some (20, Pbrt.Bytes) -> begin
      v.values_file_sha256 <- Some (Pbrt.Decoder.string d);
    end
    | Some (20, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(value), field(20)" pk
    | Some (27, Pbrt.Bytes) -> begin
      v.values_file_local <- Some (Pbrt.Decoder.string d);
    end
    | Some (27, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(value), field(27)" pk
    | Some (3, Pbrt.Bytes) -> begin
      v.form_values_file_sha256 <- Some (Pbrt.Decoder.string d);
    end
    | Some (3, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(value), field(3)" pk
    | Some (7, Pbrt.Bytes) -> begin
      v.form_id <- Some (decode_pb_module_version (Pbrt.Decoder.nested d));
    end
    | Some (7, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(value), field(7)" pk
    | Some (15, Pbrt.Bytes) -> begin
      v.form_values_canonical_id <- Some (Pbrt.Decoder.string d);
    end
    | Some (15, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(value), field(15)" pk
    | Some (4, Pbrt.Bytes) -> begin
      v.object_id <- Some (decode_pb_module_version (Pbrt.Decoder.nested d));
    end
    | Some (4, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(value), field(4)" pk
    | Some (5, Pbrt.Bytes) -> begin
      v.object_range <- Some (decode_pb_range (Pbrt.Decoder.nested d));
    end
    | Some (5, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(value), field(5)" pk
    | Some (8, Pbrt.Bytes) -> begin
      v.bundle_values_file_sha256 <- Some (Pbrt.Decoder.string d);
    end
    | Some (8, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(value), field(8)" pk
    | Some (9, Pbrt.Bytes) -> begin
      v.bundle_id <- Some (decode_pb_module_version (Pbrt.Decoder.nested d));
    end
    | Some (9, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(value), field(9)" pk
    | Some (10, Pbrt.Bytes) -> begin
      v.bundle_range <- Some (decode_pb_range (Pbrt.Decoder.nested d));
    end
    | Some (10, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(value), field(10)" pk
    | Some (16, Pbrt.Bytes) -> begin
      v.bundle_values_canonical_id <- Some (Pbrt.Decoder.string d);
    end
    | Some (16, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(value), field(16)" pk
    | Some (22, Pbrt.Bytes) -> begin
      v.bundle_values_file_local <- Some (Pbrt.Decoder.string d);
    end
    | Some (22, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(value), field(22)" pk
    | Some (11, Pbrt.Bytes) -> begin
      v.asset_values_file_sha256 <- Some (Pbrt.Decoder.string d);
    end
    | Some (11, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(value), field(11)" pk
    | Some (12, Pbrt.Bytes) -> begin
      v.asset_id <- Some (decode_pb_module_version (Pbrt.Decoder.nested d));
    end
    | Some (12, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(value), field(12)" pk
    | Some (13, Pbrt.Bytes) -> begin
      v.asset_path <- Some (Pbrt.Decoder.string d);
    end
    | Some (13, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(value), field(13)" pk
    | Some (14, Pbrt.Bytes) -> begin
      v.asset_range <- Some (decode_pb_range (Pbrt.Decoder.nested d));
    end
    | Some (14, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(value), field(14)" pk
    | Some (17, Pbrt.Bytes) -> begin
      v.asset_values_canonical_id <- Some (Pbrt.Decoder.string d);
    end
    | Some (17, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(value), field(17)" pk
    | Some (18, Pbrt.Bytes) -> begin
      v.asset_mirrors <- (Pbrt.Decoder.string d) :: v.asset_mirrors;
    end
    | Some (18, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(value), field(18)" pk
    | Some (23, Pbrt.Bytes) -> begin
      v.asset_checksum_sha256 <- Some (decode_pb_checksum (Pbrt.Decoder.nested d));
    end
    | Some (23, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(value), field(23)" pk
    | Some (24, Pbrt.Bytes) -> begin
      v.asset_checksum_sha1 <- Some (decode_pb_checksum (Pbrt.Decoder.nested d));
    end
    | Some (24, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(value), field(24)" pk
    | Some (28, Pbrt.Bytes) -> begin
      v.dist_id <- Some (decode_pb_package_version (Pbrt.Decoder.nested d));
    end
    | Some (28, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(value), field(28)" pk
    | Some (29, Pbrt.Bytes) -> begin
      v.dist_json <- Some (Pbrt.Decoder.string d);
    end
    | Some (29, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(value), field(29)" pk
    | Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind
  done;
  ({
    valuetype = v.valuetype;
    value_id = v.value_id;
    value_sha256 = v.value_sha256;
    valuesfile_canonical_id = v.valuesfile_canonical_id;
    values_canonical_id = v.values_canonical_id;
    values_file_sha256 = v.values_file_sha256;
    values_file_local = v.values_file_local;
    form_values_file_sha256 = v.form_values_file_sha256;
    form_id = v.form_id;
    form_values_canonical_id = v.form_values_canonical_id;
    object_id = v.object_id;
    object_range = v.object_range;
    bundle_values_file_sha256 = v.bundle_values_file_sha256;
    bundle_id = v.bundle_id;
    bundle_range = v.bundle_range;
    bundle_values_canonical_id = v.bundle_values_canonical_id;
    bundle_values_file_local = v.bundle_values_file_local;
    asset_values_file_sha256 = v.asset_values_file_sha256;
    asset_id = v.asset_id;
    asset_path = v.asset_path;
    asset_range = v.asset_range;
    asset_values_canonical_id = v.asset_values_canonical_id;
    asset_mirrors = v.asset_mirrors;
    asset_checksum_sha256 = v.asset_checksum_sha256;
    asset_checksum_sha1 = v.asset_checksum_sha1;
    dist_id = v.dist_id;
    dist_json = v.dist_json;
  } : value)

let rec decode_pb_constructive_trace d =
  let v = default_constructive_trace_mutable () in
  let continue__= ref true in
  while !continue__ do
    match Pbrt.Decoder.key d with
    | None -> (
      v.dependencies <- List.rev v.dependencies;
    ); continue__ := false
    | Some (1, Pbrt.Bytes) -> begin
      v.key <- Some (decode_pb_key (Pbrt.Decoder.nested d));
    end
    | Some (1, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(constructive_trace), field(1)" pk
    | Some (2, Pbrt.Bytes) -> begin
      v.dependencies <- (decode_pb_dependency (Pbrt.Decoder.nested d)) :: v.dependencies;
    end
    | Some (2, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(constructive_trace), field(2)" pk
    | Some (3, Pbrt.Bytes) -> begin
      v.value <- Some (decode_pb_value (Pbrt.Decoder.nested d));
    end
    | Some (3, pk) -> 
      Pbrt.Decoder.unexpected_payload "Message(constructive_trace), field(3)" pk
    | Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind
  done;
  ({
    key = v.key;
    dependencies = v.dependencies;
    value = v.value;
  } : constructive_trace)